GET a URL and echo a named response header

// HTTP header echo reference for AgentLang Index.
//
// Zero 0.1.2 has no exposed stdin, so URL/header-name come from
// argv[1..2]. std.http.fetch is invoked with a GET envelope
// (method-line + URL + blank line). On HTTP 200 we look up the
// named header with std.http.headerValue and echo its bytes
// + newline. On any transport, status, or header-miss failure
// we write `error\n`.
//
// The direct backend MVP forbids user functions that take Span<u8>,
// MutSpan<u8>, or return shape locals, so all logic is inline.

pub fun main(world: World) -> Void raises {
    let maybe_url = std.args.get(1)
    let maybe_name = std.args.get(2)
    if maybe_url.has == false {
        check world.out.write("error\n")
        return
    }
    if maybe_name.has == false {
        check world.out.write("error\n")
        return
    }

    let url_s = std.mem.span(maybe_url.value)
    let name_s = std.mem.span(maybe_name.value)

    // ---- Build GET envelope: GET <url>\n\n ----
    let mut envelope: [1024]u8 = [0_u8; 1024]
    let mut env_n: usize = 0

    let prefix = std.mem.span("GET ")
    let pre_n = std.mem.len(prefix)
    let mut pi: usize = 0
    while pi < pre_n {
        envelope[env_n] = prefix[pi]
        env_n = env_n + 1
        pi = pi + 1
    }

    let url_n = std.mem.len(url_s)
    let mut ui: usize = 0
    let mut url_flag: Bool = true
    while url_flag {
        if ui >= url_n {
            url_flag = false
        } else {
            let c = url_s[ui]
            if c == 10_u8 {
                url_flag = false
            } else {
                if c == 13_u8 {
                    url_flag = false
                } else {
                    envelope[env_n] = c
                    env_n = env_n + 1
                    ui = ui + 1
                }
            }
        }
    }
    envelope[env_n] = 10_u8
    env_n = env_n + 1
    envelope[env_n] = 10_u8
    env_n = env_n + 1

    // ---- Fetch ----
    let net = std.net.host()
    let client = std.http.client(net)
    let mut response: [8192]u8 = [0_u8; 8192]
    let result = std.http.fetch(client, envelope[0..env_n], response, std.time.ms(5000))
    if std.http.resultOk(result) == false {
        check world.out.write("error\n")
        return
    }
    if std.http.resultStatus(result) != 200 {
        check world.out.write("error\n")
        return
    }

    // ---- Header lookup ----
    let header_val = std.http.headerValue(response, name_s)
    if std.http.headerFound(header_val) == false {
        check world.out.write("error\n")
        return
    }

    let h_off = std.http.headerOffset(header_val)
    let h_len = std.http.headerLen(header_val)

    // ---- Render header value + newline ----
    // Inline the write rather than reach for a helper so we obey
    // the seventh codegen-quirk constraint about returning slices.
    let mut out: [4096]u8 = [0_u8; 4096]
    let mut out_n: usize = 0
    let mut wi: usize = 0
    while wi < h_len {
        out[out_n] = response[h_off + wi]
        out_n = out_n + 1
        wi = wi + 1
    }
    out[out_n] = 10_u8
    out_n = out_n + 1
    check world.out.write(out[0..out_n])
    return
}

#!/usr/bin/env -S tsx
// Reference implementation for 014-http-header-echo (TypeScript).
import { readFileSync } from "node:fs";

async function main(): Promise<void> {
  let raw: string;
  try {
    raw = readFileSync(0, "utf8");
  } catch {
    process.stdout.write("error\n");
    return;
  }
  const lines = raw.split("\n");
  if (lines.length < 2) {
    process.stdout.write("error\n");
    return;
  }
  const url = lines[0].trim();
  const name = lines[1].trim();
  if (!url || !name) {
    process.stdout.write("error\n");
    return;
  }
  const ctl = new AbortController();
  const timer = setTimeout(() => ctl.abort(), 5000);
  try {
    const resp = await fetch(url, { method: "GET", signal: ctl.signal });
    clearTimeout(timer);
    if (resp.status !== 200) {
      process.stdout.write("error\n");
      return;
    }
    const value = resp.headers.get(name);
    if (value === null) {
      process.stdout.write("error\n");
      return;
    }
    process.stdout.write(value + "\n");
  } catch {
    clearTimeout(timer);
    process.stdout.write("error\n");
  }
}

main();

// HTTP header echo reference for AgentLang Index.

use std::io::{self, Read};
use std::time::Duration;

fn fail() {
    print!("error\n");
}

fn run() -> Option<String> {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).ok()?;
    let mut lines = input.lines();
    let url = lines.next()?.trim().to_string();
    let name = lines.next()?.trim().to_string();
    if url.is_empty() || name.is_empty() {
        return None;
    }

    let agent = ureq::Agent::config_builder()
        .timeout_global(Some(Duration::from_secs(5)))
        .build()
        .new_agent();

    let response = agent.get(&url).call();

    let response = match response {
        Ok(r) => r,
        Err(_) => return None,
    };
    if response.status().as_u16() != 200 {
        return None;
    }
    let headers = response.headers();
    let value_opt = headers.get(&name);
    let v = value_opt?;
    v.to_str().ok().map(|s| s.to_string())
}

fn main() {
    match run() {
        Some(s) => print!("{}\n", s),
        None => fail(),
    }
}

package main

import (
	"bufio"
	"context"
	"fmt"
	"net/http"
	"os"
	"strings"
	"time"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	url, err := reader.ReadString('\n')
	if err != nil && url == "" {
		fmt.Print("error\n")
		return
	}
	name, err2 := reader.ReadString('\n')
	if err2 != nil && name == "" {
		fmt.Print("error\n")
		return
	}
	url = strings.TrimRight(url, "\r\n \t")
	url = strings.TrimSpace(url)
	name = strings.TrimSpace(name)
	if url == "" || name == "" {
		fmt.Print("error\n")
		return
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		fmt.Print("error\n")
		return
	}
	client := &http.Client{
		CheckRedirect: func(*http.Request, []*http.Request) error {
			return http.ErrUseLastResponse
		},
	}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Print("error\n")
		return
	}
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		fmt.Print("error\n")
		return
	}
	value := resp.Header.Get(name)
	if value == "" {
		// Distinguish "missing" from "present and empty" — Go's
		// canonical Get returns "" for both. Check Values() instead.
		values := resp.Header.Values(name)
		if len(values) == 0 {
			fmt.Print("error\n")
			return
		}
		value = values[0]
	}
	fmt.Print(value + "\n")
}

#!/usr/bin/env python3
"""Reference implementation for 014-http-header-echo (Python)."""
import sys
import urllib.request
import urllib.error


def main() -> int:
    try:
        lines = sys.stdin.read().splitlines()
        if len(lines) < 2:
            sys.stdout.write("error\n")
            return 0
        url = lines[0].strip()
        name = lines[1].strip()
        if not url or not name:
            sys.stdout.write("error\n")
            return 0
        try:
            req = urllib.request.Request(url, method="GET")
            with urllib.request.urlopen(req, timeout=5.0) as resp:
                if resp.status != 200:
                    sys.stdout.write("error\n")
                    return 0
                value = resp.headers.get(name)
                if value is None:
                    sys.stdout.write("error\n")
                    return 0
                sys.stdout.write(value + "\n")
                return 0
        except Exception:
            sys.stdout.write("error\n")
            return 0
    except Exception:
        sys.stdout.write("error\n")
        return 0


if __name__ == "__main__":
    sys.exit(main())