@app-vitals/agent-lib 0.0.1 → 0.1.1

package/chat-notify.ts

@@ -0,0 +1,41 @@
+/**
+ * lib/chat-notify.ts
+ * Shared type for the chat service's outbound reply-notification webhook
+ * (CFB-4.3) — imported by both the chat service (builds/sends the event) and,
+ * potentially, the admin service (receives it at POST /admin/push/notify).
+ *
+ * Deliberately text-free: no message body/preview field. The payload is just
+ * enough for the admin side to look up subscriptions and render a generic
+ * "your agent replied" notification — the opt-in preview text (if any) is
+ * fetched separately by admin from the message itself, not carried here.
+ */
+
+/** Event fired once per newly-persisted agent reply. */
+export interface ReplyNotificationEvent {
+  threadId: string;
+  agentId: string;
+  /** Thread title, or null when the thread has none. Never coerced to "". */
+  title: string | null;
+}
+
+/**
+ * Parses `v` as a ReplyNotificationEvent, returning null on any shape
+ * mismatch (missing/wrong-typed fields). Used by callers that receive this
+ * payload over the wire and need to validate it before trusting the shape.
+ */
+export function parseReplyNotificationEvent(
+  v: unknown,
+): ReplyNotificationEvent | null {
+  if (typeof v !== "object" || v === null) return null;
+  const obj = v as Record<string, unknown>;
+
+  if (typeof obj.threadId !== "string") return null;
+  if (typeof obj.agentId !== "string") return null;
+  if (typeof obj.title !== "string" && obj.title !== null) return null;
+
+  return {
+    threadId: obj.threadId,
+    agentId: obj.agentId,
+    title: obj.title,
+  };
+}

package/chat-notify.unit.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test";
+import {
+  type ReplyNotificationEvent,
+  parseReplyNotificationEvent,
+} from "./chat-notify.ts";
+
+describe("parseReplyNotificationEvent — valid shapes", () => {
+  test("parses a full event with a string title", () => {
+    const input = { threadId: "thread-1", agentId: "agent-1", title: "Hi" };
+    const result = parseReplyNotificationEvent(input);
+    expect(result).toEqual({
+      threadId: "thread-1",
+      agentId: "agent-1",
+      title: "Hi",
+    } satisfies ReplyNotificationEvent);
+  });
+
+  test("parses an event with a null title", () => {
+    const input = { threadId: "thread-1", agentId: "agent-1", title: null };
+    const result = parseReplyNotificationEvent(input);
+    expect(result).toEqual({
+      threadId: "thread-1",
+      agentId: "agent-1",
+      title: null,
+    });
+  });
+});
+
+describe("parseReplyNotificationEvent — invalid shapes", () => {
+  test("rejects null", () => {
+    expect(parseReplyNotificationEvent(null)).toBeNull();
+  });
+
+  test("rejects a non-object", () => {
+    expect(parseReplyNotificationEvent("not an object")).toBeNull();
+  });
+
+  test("rejects a missing threadId", () => {
+    expect(
+      parseReplyNotificationEvent({ agentId: "agent-1", title: null }),
+    ).toBeNull();
+  });
+
+  test("rejects a missing agentId", () => {
+    expect(
+      parseReplyNotificationEvent({ threadId: "thread-1", title: null }),
+    ).toBeNull();
+  });
+
+  test("rejects a non-string threadId", () => {
+    expect(
+      parseReplyNotificationEvent({
+        threadId: 123,
+        agentId: "agent-1",
+        title: null,
+      }),
+    ).toBeNull();
+  });
+
+  test("rejects a non-string agentId", () => {
+    expect(
+      parseReplyNotificationEvent({
+        threadId: "thread-1",
+        agentId: 123,
+        title: null,
+      }),
+    ).toBeNull();
+  });
+
+  test("rejects a non-string, non-null title", () => {
+    expect(
+      parseReplyNotificationEvent({
+        threadId: "thread-1",
+        agentId: "agent-1",
+        title: 42,
+      }),
+    ).toBeNull();
+  });
+
+  test("rejects a missing title field", () => {
+    expect(
+      parseReplyNotificationEvent({
+        threadId: "thread-1",
+        agentId: "agent-1",
+      }),
+    ).toBeNull();
+  });
+});

package/claim-ttl.ts

@@ -0,0 +1,12 @@
+import { DEFAULT_CLAUDE_TIMEOUT_MS } from "./claude-timeout.ts";
+
+/** Extra headroom added on top of the session timeout (5min). */
+export const CLAIM_TTL_BUFFER_MS = 300_000;
+
+/**
+ * Default claim TTL: how long a claim (Task or PR review/patch/deploy) remains
+ * valid without a heartbeat before it's eligible for reaping. Must exceed
+ * DEFAULT_CLAUDE_TIMEOUT_MS so a claim isn't reaped mid-session.
+ */
+export const DEFAULT_CLAIM_TTL_MS =
+  DEFAULT_CLAUDE_TIMEOUT_MS + CLAIM_TTL_BUFFER_MS;

package/claim-ttl.unit.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import { CLAIM_TTL_BUFFER_MS, DEFAULT_CLAIM_TTL_MS } from "./claim-ttl.ts";
+import { DEFAULT_CLAUDE_TIMEOUT_MS } from "./claude-timeout.ts";
+
+describe("claim-ttl constants", () => {
+  test("CLAIM_TTL_BUFFER_MS is 300_000 (5min)", () => {
+    expect(CLAIM_TTL_BUFFER_MS).toBe(300_000);
+  });
+
+  test("DEFAULT_CLAIM_TTL_MS is 3_900_000 (65min)", () => {
+    expect(DEFAULT_CLAIM_TTL_MS).toBe(3_900_000);
+  });
+
+  test("DEFAULT_CLAIM_TTL_MS is computed as the sum of the other two constants", () => {
+    expect(DEFAULT_CLAIM_TTL_MS).toBe(
+      DEFAULT_CLAUDE_TIMEOUT_MS + CLAIM_TTL_BUFFER_MS,
+    );
+  });
+
+  // Relocated from claude-timeout.unit.test.ts (AEP-4.1): claim-ttl is the
+  // task-store side, so the cross-module invariant belongs here and the
+  // platform-set lib test no longer imports it.
+  test("DEFAULT_CLAIM_TTL_MS exceeds DEFAULT_CLAUDE_TIMEOUT_MS", () => {
+    expect(DEFAULT_CLAIM_TTL_MS).toBeGreaterThan(DEFAULT_CLAUDE_TIMEOUT_MS);
+  });
+});

package/claude-timeout.ts

@@ -0,0 +1,10 @@
+/**
+ * The `claude -p` hard ceiling timeout (1hr) — a backstop, not the primary
+ * timeout. The idle-reset timer (`SHIPWRIGHT_CLAUDE_IDLE_TIMEOUT_MS`, default
+ * 25min, see `agent/src/runtime/config.ts`) is cleared/restarted on every stdout line
+ * and is what fires for the vast majority of hung/stuck sessions. This
+ * ceiling only fires for a session that stays continuously active (so the
+ * idle timer keeps resetting) but never converges — e.g. a runaway loop that
+ * keeps emitting output without ever finishing.
+ */
+export const DEFAULT_CLAUDE_TIMEOUT_MS = 3_600_000;

package/claude-timeout.unit.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_CLAUDE_TIMEOUT_MS } from "./claude-timeout.ts";
+
+describe("claude-timeout", () => {
+  test("DEFAULT_CLAUDE_TIMEOUT_MS is 3_600_000 (1hr hard ceiling)", () => {
+    expect(DEFAULT_CLAUDE_TIMEOUT_MS).toBe(3_600_000);
+  });
+});

package/cli-flags.ts

@@ -0,0 +1,83 @@
+/**
+ * lib/cli-flags.ts
+ * Generalized CLI flag parser: supports both `--flag value` and
+ * `--flag=value` syntax. Generalizes `agent/src/runtime/cli-args.ts`'s narrow,
+ * hand-rolled `parseCliArgs` (which only supports `--flag value` for exactly
+ * three flags) so any script can declare the flags it cares about.
+ *
+ * Pure argv parsing — no env var fallback. Beyond string flags it supports
+ * boolean (presence) flags and repeatable (multi-value) flags. Unknown flags (not declared in
+ * `flagSpecs`) are silently ignored, matching `parseCliArgs`'s tolerant
+ * behavior. Callers that want an env var fallback (see `parseCliArgs` for
+ * that pattern) layer it on top of this helper's result.
+ */
+
+/** Parsed string-flag values, keyed by the exact flag string passed in `flagSpecs` (e.g. `"--agent-id"`). */
+type ParsedFlags<Flags extends readonly string[]> = Record<
+  Flags[number],
+  string | undefined
+>;
+
+/** Optional flag kinds beyond the plain `--flag value` string flags. */
+interface FlagKinds<
+  Bools extends readonly string[],
+  Multi extends readonly string[],
+> {
+  /** Presence-only flags: `true` when passed (bare, or `--flag=true`/`--flag=false`), else `false`. Never consume the next token. */
+  booleans?: Bools;
+  /** Repeatable value flags: every occurrence is collected in order; `[]` when absent. */
+  multi?: Multi;
+}
+
+type ParsedKinds<
+  Bools extends readonly string[],
+  Multi extends readonly string[],
+> = Record<Bools[number], boolean> & Record<Multi[number], string[]>;
+
+/**
+ * Parses `argv` for the flags declared in `flagSpecs`, supporting both
+ * `--flag value` and `--flag=value` syntax. Flags not declared in
+ * `flagSpecs` are ignored without error. A declared flag absent from `argv`
+ * (or a `--flag value` form flag with no following value) resolves to
+ * `undefined`.
+ *
+ * `kinds.booleans` and `kinds.multi` declare additional flag kinds, returned
+ * alongside the string flags (see `FlagKinds`).
+ */
+export function parseFlags<
+  const Flags extends readonly string[],
+  const Bools extends readonly string[] = readonly [],
+  const Multi extends readonly string[] = readonly [],
+>(
+  argv: readonly string[],
+  flagSpecs: Flags,
+  kinds: FlagKinds<Bools, Multi> = {},
+): ParsedFlags<Flags> & ParsedKinds<Bools, Multi> {
+  const strings = new Set<string>(flagSpecs);
+  const booleans = new Set<string>(kinds.booleans ?? []);
+  const multi = new Set<string>(kinds.multi ?? []);
+  const result: Record<string, string | boolean | string[] | undefined> = {};
+  for (const flag of strings) result[flag] = undefined;
+  for (const flag of booleans) result[flag] = false;
+  for (const flag of multi) result[flag] = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    const eqIdx = arg.indexOf("=");
+    const flag = eqIdx === -1 ? arg : arg.slice(0, eqIdx);
+    const inline = eqIdx === -1 ? undefined : arg.slice(eqIdx + 1);
+
+    if (booleans.has(flag)) {
+      result[flag] = inline === undefined ? true : inline !== "false";
+    } else if (strings.has(flag) || multi.has(flag)) {
+      const value = inline ?? argv[i + 1];
+      if (value === undefined) continue;
+      if (inline === undefined) i++;
+      if (multi.has(flag)) (result[flag] as string[]).push(value);
+      else result[flag] = value;
+    }
+  }
+
+  return result as ParsedFlags<Flags> & ParsedKinds<Bools, Multi>;
+}

package/cli-flags.unit.test.ts

@@ -0,0 +1,137 @@
+/**
+ * lib/cli-flags.unit.test.ts
+ *
+ * Unit tests for the generalized CLI flag parser.
+ * Pure logic — no I/O, no env side effects.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { parseFlags } from "./cli-flags.ts";
+
+describe("parseFlags — `--flag value` syntax", () => {
+  test("parses a single flag", () => {
+    const result = parseFlags(["--agent-id", "agent-123"], ["--agent-id"]);
+    expect(result["--agent-id"]).toBe("agent-123");
+  });
+
+  test("parses multiple flags together", () => {
+    const result = parseFlags(
+      ["--agent-id", "agent-abc", "--api-url", "https://api.test.com"],
+      ["--agent-id", "--api-url", "--api-key"],
+    );
+    expect(result["--agent-id"]).toBe("agent-abc");
+    expect(result["--api-url"]).toBe("https://api.test.com");
+  });
+});
+
+describe("parseFlags — `--flag=value` syntax", () => {
+  test("parses a single flag", () => {
+    const result = parseFlags(["--db-url=postgres://localhost"], ["--db-url"]);
+    expect(result["--db-url"]).toBe("postgres://localhost");
+  });
+
+  test("parses multiple flags together", () => {
+    const result = parseFlags(
+      ["--agent-id=agent-abc", "--api-url=https://api.test.com"],
+      ["--agent-id", "--api-url"],
+    );
+    expect(result["--agent-id"]).toBe("agent-abc");
+    expect(result["--api-url"]).toBe("https://api.test.com");
+  });
+
+  test("handles an empty value after the equals sign", () => {
+    const result = parseFlags(["--db-url="], ["--db-url"]);
+    expect(result["--db-url"]).toBe("");
+  });
+});
+
+describe("parseFlags — mixed syntax", () => {
+  test("parses one flag in `--flag value` form and another in `--flag=value` form", () => {
+    const result = parseFlags(
+      ["--agent-id", "agent-abc", "--api-url=https://api.test.com"],
+      ["--agent-id", "--api-url"],
+    );
+    expect(result["--agent-id"]).toBe("agent-abc");
+    expect(result["--api-url"]).toBe("https://api.test.com");
+  });
+});
+
+describe("parseFlags — missing flag", () => {
+  test("returns undefined for a declared flag that is not present in argv", () => {
+    const result = parseFlags(
+      ["--agent-id", "agent-abc"],
+      ["--agent-id", "--api-url"],
+    );
+    expect(result["--api-url"]).toBeUndefined();
+  });
+
+  test("returns undefined for every declared flag when argv is empty", () => {
+    const result = parseFlags([], ["--agent-id", "--api-url"]);
+    expect(result["--agent-id"]).toBeUndefined();
+    expect(result["--api-url"]).toBeUndefined();
+  });
+
+  test("returns undefined when a `--flag value` form flag has no following value (end of argv)", () => {
+    const result = parseFlags(["--agent-id"], ["--agent-id"]);
+    expect(result["--agent-id"]).toBeUndefined();
+  });
+});
+
+describe("parseFlags — unknown flags are ignored (tolerant behavior)", () => {
+  test("skips a flag not declared in flagSpecs", () => {
+    const result = parseFlags(
+      ["--unknown", "value", "--agent-id", "x"],
+      ["--agent-id"],
+    );
+    expect(result["--agent-id"]).toBe("x");
+    expect(result).not.toHaveProperty("--unknown");
+  });
+
+  test("skips an unknown flag in `--flag=value` form", () => {
+    const result = parseFlags(
+      ["--unknown=value", "--agent-id=x"],
+      ["--agent-id"],
+    );
+    expect(result["--agent-id"]).toBe("x");
+    expect(result).not.toHaveProperty("--unknown");
+  });
+});
+
+describe("parseFlags — boolean flags", () => {
+  test("true when present, false when absent, never consumes next token", () => {
+    const r = parseFlags(["--dry-run", "--name", "x"], ["--name"], {
+      booleans: ["--dry-run", "--verbose"],
+    });
+    expect(r["--dry-run"]).toBe(true);
+    expect(r["--verbose"]).toBe(false);
+    expect(r["--name"]).toBe("x");
+  });
+
+  test("honours --flag=false", () => {
+    const r = parseFlags(["--dry-run=false"], [], { booleans: ["--dry-run"] });
+    expect(r["--dry-run"]).toBe(false);
+  });
+});
+
+describe("parseFlags — repeatable flags", () => {
+  test("collects every occurrence in order, both syntaxes", () => {
+    const r = parseFlags(["--repo", "a/b", "--repo=c/d", "--repo", "e/f"], [], {
+      multi: ["--repo"],
+    });
+    expect(r["--repo"]).toEqual(["a/b", "c/d", "e/f"]);
+  });
+
+  test("empty array when absent; trailing flag without value is skipped", () => {
+    expect(parseFlags([], [], { multi: ["--repo"] })["--repo"]).toEqual([]);
+    expect(parseFlags(["--repo"], [], { multi: ["--repo"] })["--repo"]).toEqual(
+      [],
+    );
+  });
+
+  test("string-only call shape is unchanged", () => {
+    expect(parseFlags(["--a", "1"], ["--a", "--b"])).toEqual({
+      "--a": "1",
+      "--b": undefined,
+    });
+  });
+});

package/clone-plan.ts

@@ -0,0 +1,73 @@
+/**
+ * lib/clone-plan.ts
+ * Pure planning helper for "which repos still need `gh repo clone`" —
+ * shared by scripts/hitl.ts (local dev-loop bootstrap),
+ * scripts/agent-workspace-pull.ts (mirrors a real agent's repos locally),
+ * and agent/src/runtime/sync-config-clone.ts (the deployed agent's config-sync
+ * auto-clone step).
+ *
+ * Extracted out of hitl.ts (AWP-1.1) so neither script reaches into the
+ * other's module — both import this shared helper instead. Lives in `lib/`
+ * (not `scripts/`) because the deployed agent imports it too and the
+ * runtime stage of agent/Dockerfile copies `lib/` but not `scripts/` — a
+ * `scripts/` import would resolve locally and crash-loop in the container.
+ */
+
+import { join } from "node:path";
+
+/**
+ * Given the configured "org/repo" list, the repos dir, and an injectable
+ * existence check, reports which repos still need cloning (and their
+ * destination path). Repos already present under reposDir are left
+ * untouched. Kept side-effect free so it's unit-testable without touching
+ * the filesystem or network.
+ */
+export function computeMissingClones(
+  repos: string[],
+  reposDir: string,
+  exists: (path: string) => boolean,
+): { repo: string; dest: string }[] {
+  return repos
+    .map((repo) => ({
+      repo,
+      dest: join(reposDir, repo.slice(repo.lastIndexOf("/") + 1)),
+    }))
+    .filter(({ dest }) => !exists(dest));
+}
+
+interface RepoNameCollision {
+  /** The later-listed repo — the one a sync should skip. */
+  repo: string;
+  /** The earlier-listed repo that already claimed the `repos/<name>` folder. */
+  collidesWith: string;
+}
+
+function splitRepo(repo: string): { owner: string; name: string } {
+  const i = repo.lastIndexOf("/");
+  return {
+    owner: repo.slice(0, i).toLowerCase(),
+    name: repo.slice(i + 1).toLowerCase(),
+  };
+}
+
+/**
+ * Reports repos whose basename matches an earlier-listed repo under a
+ * different owner (case-insensitive). `repos/<name>` is keyed by basename
+ * alone, so two such repos would share one folder and a clone/push could
+ * land on the wrong customer's repo. The later-listed repo is the collider;
+ * identical repos (same owner and name) are not collisions.
+ */
+export function findRepoNameCollisions(repos: string[]): RepoNameCollision[] {
+  const firstByName = new Map<string, { repo: string; owner: string }>();
+  const collisions: RepoNameCollision[] = [];
+  for (const repo of repos) {
+    const { owner, name } = splitRepo(repo);
+    const first = firstByName.get(name);
+    if (!first) {
+      firstByName.set(name, { repo, owner });
+    } else if (first.owner !== owner) {
+      collisions.push({ repo, collidesWith: first.repo });
+    }
+  }
+  return collisions;
+}

package/clone-plan.unit.test.ts

@@ -0,0 +1,69 @@
+/**
+ * lib/clone-plan.unit.test.ts
+ * Unit tests for computeMissingClones() — relocated from hitl.unit.test.ts
+ * (AWP-1.1) when the function was extracted out of scripts/hitl.ts into this
+ * shared module. Same assertions, moved not duplicated.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { computeMissingClones, findRepoNameCollisions } from "./clone-plan.ts";
+
+describe("computeMissingClones", () => {
+  test("returns [] for an empty repos list", () => {
+    expect(computeMissingClones([], "/ws/repos", () => false)).toEqual([]);
+  });
+
+  test("skips repos already cloned under reposDir", () => {
+    const existing = new Set(["/ws/repos/shipwright"]);
+    const missing = computeMissingClones(
+      ["app-vitals/shipwright"],
+      "/ws/repos",
+      (path) => existing.has(path),
+    );
+    expect(missing).toEqual([]);
+  });
+
+  test("includes missing repos with the correct dest path", () => {
+    const missing = computeMissingClones(
+      ["app-vitals/shipwright"],
+      "/ws/repos",
+      () => false,
+    );
+    expect(missing).toEqual([
+      { repo: "app-vitals/shipwright", dest: "/ws/repos/shipwright" },
+    ]);
+  });
+
+  test("mix of already-cloned and missing repos — only missing ones are returned", () => {
+    const existing = new Set(["/ws/repos/shipwright"]);
+    const missing = computeMissingClones(
+      ["app-vitals/shipwright", "some-org/other-repo"],
+      "/ws/repos",
+      (path) => existing.has(path),
+    );
+    expect(missing).toEqual([
+      { repo: "some-org/other-repo", dest: "/ws/repos/other-repo" },
+    ]);
+  });
+});
+
+describe("findRepoNameCollisions", () => {
+  test("reports the later-listed same-basename repo under a different owner", () => {
+    expect(
+      findRepoNameCollisions(["acme/api", "other/web", "globex/api"]),
+    ).toEqual([{ repo: "globex/api", collidesWith: "acme/api" }]);
+  });
+
+  test("is case-insensitive on owner and name", () => {
+    expect(findRepoNameCollisions(["Acme/API", "globex/api"])).toEqual([
+      { repo: "globex/api", collidesWith: "Acme/API" },
+    ]);
+    expect(findRepoNameCollisions(["Acme/api", "acme/API"])).toEqual([]);
+  });
+
+  test("ignores identical repos and distinct names", () => {
+    expect(findRepoNameCollisions(["acme/api", "acme/api"])).toEqual([]);
+    expect(findRepoNameCollisions(["acme/api", "acme/web"])).toEqual([]);
+    expect(findRepoNameCollisions([])).toEqual([]);
+  });
+});

package/default-account.ts

@@ -0,0 +1,5 @@
+/**
+ * The account every pre-multi-tenancy task-store row belongs to. Never use
+ * NULL for task-store accountId — the column is NOT NULL DEFAULT 'default'.
+ */
+export const DEFAULT_ACCOUNT_ID = "default";

package/default-account.unit.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from "bun:test";
+import { DEFAULT_ACCOUNT_ID } from "./default-account.ts";
+
+describe("DEFAULT_ACCOUNT_ID", () => {
+  it("is the literal 'default' matching the migration's column default", () => {
+    expect(DEFAULT_ACCOUNT_ID).toBe("default");
+  });
+});

package/default-agent-env.ts

@@ -0,0 +1,15 @@
+/**
+ * lib/default-agent-env.ts
+ * Non-secret env vars seeded onto every newly created agent so they're visible
+ * (and editable) in the agent's env view instead of being an invisible runtime
+ * fallback. Secrets (CLAUDE_CODE_OAUTH_TOKEN, GH_TOKEN, ...) are never defaulted
+ * here — see secret-env-vars.ts.
+ */
+
+/** Model used when an agent has no ANTHROPIC_MODEL set. */
+export const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-5-5";
+
+/** Env vars written to a new agent's AgentEnv at creation. Operator-supplied values win. */
+export const DEFAULT_AGENT_ENV: Readonly<Record<string, string>> = {
+  ANTHROPIC_MODEL: DEFAULT_ANTHROPIC_MODEL,
+};

package/default-agent-env.unit.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "bun:test";
+import { DEFAULT_AGENT_ENV } from "./default-agent-env.ts";
+import { SECRET_ENV_VARS } from "./secret-env-vars.ts";
+
+describe("DEFAULT_AGENT_ENV", () => {
+  it("never defaults a secret-shaped env var", () => {
+    for (const key of Object.keys(DEFAULT_AGENT_ENV)) {
+      expect(SECRET_ENV_VARS as readonly string[]).not.toContain(key);
+    }
+  });
+
+  it("defaults ANTHROPIC_MODEL to a non-empty value", () => {
+    expect(DEFAULT_AGENT_ENV.ANTHROPIC_MODEL).toMatch(/^claude-/);
+  });
+
+  it("defaults ANTHROPIC_MODEL to claude-sonnet-5-5", () => {
+    expect(DEFAULT_AGENT_ENV.ANTHROPIC_MODEL).toBe("claude-sonnet-5-5");
+  });
+});

package/github-login.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns true when `s` is a valid GitHub login: alphanumeric characters and
+ * single hyphens only, no leading/trailing hyphen, no consecutive hyphens,
+ * and a max length of 39 characters (GitHub's own username constraints).
+ *
+ * Also accepts GitHub App bot logins in the format "app/<slug>", where slug
+ * follows the same validation rules as regular logins.
+ */
+export function isGithubLogin(s: string): boolean {
+  const LOGIN_PATTERN = /^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$/;
+
+  if (s.startsWith("app/")) {
+    const slug = s.slice(4);
+    return slug.length > 0 && slug.length <= 39 && LOGIN_PATTERN.test(slug);
+  }
+
+  return (
+    s.length > 0 && s.length <= 39 && LOGIN_PATTERN.test(s)
+  );
+}