dev-orchestrator-connector 0.1.0 → 0.1.1

package/dist/worker.js

@@ -0,0 +1,192 @@
+import { createHash } from "node:crypto";
+import { dirname } from "node:path";
+import { Journal } from "./journal.js";
+import { API, APIError } from "./api.js";
+import { CodexSession, RepeatedFailureError, CodexBlockedError } from "./codex.js";
+import { RepositoryWorkspace } from "./repository.js";
+import { Publisher } from "./publisher.js";
+export async function emitDurably(api, journal, state, kind, data) {
+    if (state.pending_event)
+        throw new Error("A previous event still needs acknowledgement.");
+    state.sequence++;
+    state.pending_event = { sequence: state.sequence, kind, data };
+    await journal.save(state);
+    const result = await api.post("/executor/events", { lease: state.lease, event: state.pending_event });
+    delete state.pending_event;
+    await journal.save(state);
+    return result;
+}
+export async function recover(api, journal, repositories, dataRoot) {
+    const state = await journal.load();
+    if (!state)
+        return;
+    const result = await api.post("/executor/reconcile", { lease: state.lease, journal: { pending_event: state.pending_event ?? null } });
+    let terminalState = result.state;
+    if (result.action === "replay" && state.pending_event) {
+        const kind = state.pending_event.kind;
+        const acknowledgement = await api.post("/executor/events", { lease: state.lease, event: state.pending_event });
+        if (["succeeded", "blocked", "failed", "cancelled"].includes(acknowledgement?.state))
+            terminalState = acknowledgement.state;
+        if (["started", "progress"].includes(kind))
+            terminalState = (await api.post("/executor/reconcile", { lease: state.lease, journal: { pending_event: null } })).state;
+    }
+    else if (result.action !== "acknowledge")
+        throw new Error("Task reconciliation needs operator attention.");
+    if (state.workspace && repositories && dataRoot && ["succeeded", "blocked", "failed", "cancelled"].includes(terminalState)) {
+        await repositories.markTerminal(state.workspace, terminalState === "succeeded" ? "success" : "failure");
+    }
+    await journal.clear();
+}
+export async function runLoop(config, root, signal) {
+    const api = new API(config.server, config.token);
+    const journal = new Journal(root);
+    const repositories = new RepositoryWorkspace();
+    await recover(api, journal, repositories, dirname(root));
+    const health = CodexSession.start(config.codexBinary ?? "codex", root);
+    let authenticated = false;
+    try {
+        await health.initialize();
+        authenticated = await health.authenticated();
+    }
+    finally {
+        health.stop();
+    }
+    await api.post("/executor/heartbeat", { protocol: 1, codex_authenticated: authenticated, platform: process.platform });
+    if (!authenticated)
+        throw new Error("Sign in to the official Codex CLI with your own ChatGPT account before starting this connector.");
+    while (!signal.aborted) {
+        try {
+            await recover(api, journal, repositories, dirname(root));
+            await api.post("/executor/heartbeat", { protocol: 1, codex_authenticated: true, platform: process.platform });
+            const claimStarted = performance.now();
+            const lease = await api.post("/executor/claim", {});
+            if (lease)
+                await execute(config, api, journal, { lease, sequence: lease.sequence ?? 0 }, claimStarted, signal, { dataRoot: dirname(root) });
+        }
+        catch (error) {
+            if (signal.aborted)
+                break;
+            if (error instanceof APIError && error.status === 401)
+                throw new Error("Executor access was revoked. Pair again with an authorized owner.");
+            console.error("Control-plane operation interrupted. Preserved task state; reconnecting without rerunning unacknowledged work.");
+        }
+        await new Promise(resolve => setTimeout(resolve, 5_000));
+    }
+}
+export async function execute(config, api, journal, state, claimStarted, signal, dependencies = {}) {
+    const controller = new AbortController();
+    let session;
+    let phase = "github_installation_required";
+    let deadline = claimStarted + Math.min(state.lease.expires_in_ms ?? 90_000, 90_000) - 5_000;
+    const abort = () => { controller.abort(); session?.stop(); };
+    let workspacePath;
+    signal.addEventListener("abort", abort, { once: true });
+    const safety = setInterval(() => { if (performance.now() >= deadline)
+        abort(); }, 250);
+    const renewal = setInterval(async () => {
+        const started = performance.now();
+        try {
+            const result = await api.post("/executor/renew", state.lease);
+            if (!controller.signal.aborted)
+                deadline = started + Math.min(result.expires_in_ms, 90_000) - 5_000;
+        }
+        catch (error) {
+            if (error instanceof APIError && [401, 409].includes(error.status))
+                abort();
+            // A transport failure does not extend the last acknowledged deadline.
+        }
+    }, 20_000);
+    const timeBudget = setTimeout(abort, 20 * 60_000);
+    try {
+        await journal.save(state);
+        await emitDurably(api, journal, state, "started", {});
+        await emitDurably(api, journal, state, "progress", { stage: "repository_preparing" });
+        const dataRoot = dependencies.dataRoot ?? dirname(journal.root);
+        const repositories = dependencies.repositories ?? new RepositoryWorkspace();
+        await repositories.cleanupExpired(dataRoot);
+        const credential = await api.post("/executor/github-token", { lease: state.lease, purpose: "checkout" });
+        phase = "workspace_setup_failed";
+        const workspace = await repositories.prepare(dataRoot, state.lease, credential);
+        workspacePath = workspace.path;
+        const snapshot = state.lease.snapshot ?? {};
+        const instructionsPath = await repositories.writeProjectInstructions(workspace.path, snapshot.instructions ?? "");
+        state.workspace = workspace.path;
+        state.baseline = workspace.baseline;
+        await journal.save(state);
+        if (controller.signal.aborted)
+            throw new Error("Lease ended.");
+        await emitDurably(api, journal, state, "progress", { stage: "workspace_ready" });
+        phase = "authentication_required";
+        session = CodexSession.start(config.codexBinary ?? "codex", workspace.path);
+        await session.initialize();
+        if (!await session.authenticated())
+            throw new Error("Local account is not signed in.");
+        phase = "execution_failed";
+        const prompt = [
+            "Implement this development task end to end in this isolated checkout.",
+            "Read and respect the repository's AGENTS.md and project-scoped skills. Do not change global skills or configuration.",
+            "Validate changes and create a Conventional Commit on the existing issue branch. Do not push, create a PR, merge, or deploy: the trusted connector handles publication after your turn.",
+            "Do not invent external access or credentials. If essential context is missing, report a real blocker. Network access is disabled in this evaluation sandbox.",
+            instructionsPath
+                ? "Project instructions: read and follow the file at " + instructionsPath + " before making changes."
+                : "Project instructions:\n" + String(snapshot.instructions ?? ""),
+            "Task: " + String(state.lease.title ?? ""), String(state.lease.prompt ?? "")
+        ].join("\n\n");
+        await session.run(workspace.path, prompt, typeof snapshot.model === "string" ? snapshot.model : undefined, controller.signal, stage => emitDurably(api, journal, state, "progress", { stage }));
+        session.stop();
+        session = undefined;
+        phase = "publication_failed";
+        await api.post("/executor/renew", state.lease);
+        const publicationContext = { workspace: workspace.path, repository: String(snapshot.repository ?? ""), baseBranch: String(snapshot.base_branch ?? ""), branch: workspace.branch, baseline: workspace.baseline };
+        const publisher = dependencies.publisherFactory?.(publicationContext) ?? new Publisher(publicationContext);
+        const status = await publisher.status(controller.signal);
+        if (status.changed) {
+            await emitDurably(api, journal, state, "progress", { stage: "publishing" });
+            const publishCredential = await api.post("/executor/github-token", { lease: state.lease, purpose: "publish" });
+            const result = await publisher.publish(state.lease.title ?? "Development task", `## Summary\n\nCompleted by the customer-owned local executor.\n\n## Validation\n\nReview the committed changes and repository checks before merging.\n\nRun: ${state.lease.id}`, publishCredential, controller.signal);
+            if (controller.signal.aborted)
+                throw new Error("Lease ended.");
+            await emitDurably(api, journal, state, "progress", { stage: "pr_verifying" });
+            const acknowledgement = await emitDurably(api, journal, state, "candidate", result);
+            if (acknowledgement?.state === "succeeded")
+                await repositories.markTerminal(workspace.path, "success").catch(() => { });
+        }
+        else {
+            const acknowledgement = await emitDurably(api, journal, state, "no_changes", {});
+            if (acknowledgement?.state === "succeeded")
+                await repositories.markTerminal(workspace.path, "success").catch(() => { });
+        }
+        await journal.clear();
+    }
+    catch (error) {
+        session?.stop();
+        if (controller.signal.aborted || state.pending_event)
+            throw error;
+        if (error instanceof APIError && ["github_installation_required", "github_permission_denied", "base_branch_missing", "github_unavailable", "local_policy_denied"].includes(error.code))
+            phase = error.code;
+        else if (error instanceof APIError && error.code === "provider_authentication")
+            phase = "github_permission_denied";
+        else if (error instanceof APIError && ["provider_rejected", "provider_rate_limit", "provider_unavailable"].includes(error.code))
+            phase = "github_unavailable";
+        else if (error instanceof Error && /Selected base branch does not resolve to a commit/i.test(error.message))
+            phase = "base_branch_missing";
+        else if (error instanceof Error && /Repository setup failed|worktree|managed repository cache|Task repository snapshot/i.test(error.message))
+            phase = "workspace_setup_failed";
+        if (error instanceof CodexBlockedError)
+            phase = "missing_context";
+        const fingerprint = error instanceof RepeatedFailureError ? error.fingerprint : createHash("sha256").update(phase + ":" + (error instanceof Error ? error.message : "unknown")).digest("hex");
+        const kind = ["authentication_required", "local_policy_denied", "github_installation_required", "github_permission_denied", "base_branch_missing", "missing_context", "workspace_setup_failed"].includes(phase) ? "blocked" : "failure";
+        const acknowledgement = await emitDurably(api, journal, state, kind, { category: phase, fingerprint, occurrences: error instanceof RepeatedFailureError ? 3 : 1 });
+        if (workspacePath && ["blocked", "cancelled", "failed"].includes(acknowledgement?.state)) {
+            await (dependencies.repositories ?? new RepositoryWorkspace()).markTerminal(workspacePath, "failure").catch(() => { });
+        }
+        await journal.clear();
+    }
+    finally {
+        clearInterval(safety);
+        clearInterval(renewal);
+        clearTimeout(timeBudget);
+        signal.removeEventListener("abort", abort);
+        session?.stop();
+    }
+}

package/dist/workspace.js

@@ -0,0 +1,2 @@
+export const validBranch = (value) => typeof value === "string" && value.length <= 200 && /^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(value) && !value.includes("..") && !value.includes("//") && value.split("/").every(part => part && !part.startsWith(".") && !part.endsWith(".") && !part.endsWith(".lock"));
+export const validRepository = (value) => typeof value === "string" && value.length <= 200 && /^[A-Za-z0-9][A-Za-z0-9_-]*\/[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value) && !value.includes("..") && !value.endsWith(".git");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-orchestrator-connector",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Run a customer-owned local Codex executor for Dev Orchestrator.",
   "type": "module",
   "bin": {
@@ -8,13 +8,20 @@
   },
   "files": [
     "bin/",
-    "src/"
+    "dist/"
   ],
-  "engines": { "node": ">=22.18.0" },
+  "engines": {
+    "node": ">=22.18.0"
+  },
   "scripts": {
-    "test": "node --experimental-strip-types --test test/*.test.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "npm run build && node --experimental-strip-types --test test/*.test.ts",
     "check": "tsc --noEmit",
-    "start": "node --experimental-strip-types src/cli.ts"
+    "start": "npm run build && node dist/cli.js"
   },
-  "devDependencies": { "@types/node": "22.18.8", "typescript": "5.9.3" }
+  "devDependencies": {
+    "@types/node": "22.18.8",
+    "typescript": "5.9.3"
+  }
 }

package/src/activity.ts

@@ -1,33 +0,0 @@
-export type ActivityStage =
-  | "agent_started"
-  | "working"
-  | "editing"
-  | "validating"
-  | "checks_passed";
-
-const validationCommand = /\b(test|tests|spec|lint|format|typecheck|type-check|check|build|compile)\b/i;
-
-export function activityForNotification(message: any): ActivityStage | undefined {
-  if (!message || typeof message !== "object" || !message.params) return undefined;
-
-  if (message.method === "turn/started") return "agent_started";
-
-  const item = message.params.item;
-  if (message.method === "item/started") {
-    if (item?.type === "fileChange") return "editing";
-    if (item?.type === "commandExecution") {
-      return validationCommand.test(String(item.command ?? "")) ? "validating" : "working";
-    }
-  }
-
-  if (
-    message.method === "item/completed" &&
-    item?.type === "commandExecution" &&
-    validationCommand.test(String(item.command ?? "")) &&
-    item.exitCode === 0
-  ) {
-    return "checks_passed";
-  }
-
-  return undefined;
-}

package/src/api.ts

@@ -1,23 +0,0 @@
-import { serverURL } from "./config.ts";
-export class APIError extends Error {
-  readonly status: number;
-  readonly code: string;
-  constructor(status: number, code: string) { super(`Control plane request failed (${status}: ${code}).`); this.status=status; this.code=code; }
-}
-
-export class API {
-  readonly origin: string;
-  readonly token: string | undefined;
-  constructor(origin: string, token?: string) { this.origin=serverURL(origin); this.token=token; }
-  async post(path: string, data: unknown): Promise<any> {
-    if (!/^\/[a-z/-]+$/.test(path)) throw new Error("Invalid control-plane route.");
-    const response = await fetch(this.origin + "/api/v1" + path, {
-      method: "POST", redirect: "error", signal: AbortSignal.timeout(15_000),
-      headers: { "content-type":"application/json", ...(this.token ? {authorization:`Bearer ${this.token}`} : {}) },
-      body: JSON.stringify(data)
-    });
-    const body = await response.json() as Record<string,unknown>;
-    if (!response.ok) throw new APIError(response.status, typeof body.error === "string" && /^[a-z_]+$/.test(body.error) ? body.error : "request_failed");
-    return path === "/enroll" ? body : body.data;
-  }
-}

package/src/cli.ts

@@ -1,55 +0,0 @@
-import { hostname } from "node:os";
-import { dirname, join } from "node:path";
-import { mkdir, open, unlink } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-import { API } from "./api.ts";
-import { loadConfig, saveConfig, serverURL } from "./config.ts";
-import { CodexSession } from "./codex.ts";
-import { runLoop } from "./worker.ts";
-
-export async function main(args:string[]):Promise<void> {
-  const [action,...rest]=args;
-  if(!action || action==="help" || action==="--help") {
-    console.log("Dev Orchestrator connector\n\npair --server URL --code CODE --config /absolute/config.json\nstatus --config FILE\nrun --config FILE\n\nProjects and repository access are managed in the web app. This connector uses your official local Codex login and never modifies global provider/Git configuration.");return;
-  }
-  const opts:Record<string,string>={};
-  for(let i=0;i<rest.length;i+=2){if(!/^--[a-z-]+$/.test(rest[i]) || !rest[i+1])throw new Error("Options require --name value pairs.");opts[rest[i].slice(2)]=rest[i+1];}
-  if(!opts.config || !opts.config.startsWith("/"))throw new Error("Provide an absolute --config path.");
-  const file=opts.config;
-  if(action==="pair") {
-    // Do not consume a one-use code if a pairing already exists.
-    const reservation=await open(file+".pairing","wx",0o600).catch(()=>{throw new Error("Configuration directory must exist and no pairing may already be in progress.");});
-    try {
-      try {await loadConfig(file);throw new Error("This configuration is already paired.");}
-      catch(error){if((error as NodeJS.ErrnoException).code!=="ENOENT")throw error;}
-      const server=serverURL(opts.server);
-      const result=await new API(server).post("/enroll",{code:opts.code,name:opts.name??hostname()});
-      if(typeof result.token!=="string")throw new Error("Invalid enrollment response.");
-      await saveConfig(file,{version:2,server,token:result.token},true);
-      console.log("Paired. Ask the owner to bind a project and install its repository in the web app.");
-    } finally {await reservation.close();await unlink(file+".pairing");}
-    return;
-  }
-  const config=await loadConfig(file);
-  if(action==="allow") {
-    console.log("The local allow command is no longer needed. Bind this executor to the project and configure its GitHub App repository access in the web app.");return;
-  }
-  if(action==="status") {
-    const session=CodexSession.start(config.codexBinary??"codex",dirname(file));
-    try {await session.initialize();console.log(JSON.stringify({codex_authenticated:await session.authenticated(),server:config.server}));}
-    finally{session.stop();}return;
-  }
-  if(action!=="run")throw new Error("Unknown command. Use help.");
-  const root=join(dirname(file),"runtime");await mkdir(root,{recursive:true,mode:0o700});
-  const lock=join(root,"connector.lock");
-  const fd=await open(lock,"wx",0o600).catch(()=>{throw new Error("Connector lock exists. Confirm no connector is running before removing that exact lock file.");});
-  await fd.writeFile(String(process.pid));
-  const controller=new AbortController();
-  const stop=()=>controller.abort();process.once("SIGINT",stop);process.once("SIGTERM",stop);
-  try {console.log("Connector running. Press Ctrl+C to stop; interrupted work is preserved.");await runLoop(config,root,controller.signal);}
-  finally {controller.abort();process.off("SIGINT",stop);process.off("SIGTERM",stop);await fd.close();await unlink(lock);}
-}
-
-if(process.argv[1] && import.meta.url===pathToFileURL(process.argv[1]).href) {
-  main(process.argv.slice(2)).catch(error=>{console.error(error instanceof Error?error.message:"Connector operation failed.");process.exitCode=1;});
-}

package/src/codex.ts

@@ -1,160 +0,0 @@
-import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-import { EventEmitter } from "node:events";
-import { createHash } from "node:crypto";
-import { stopProcess } from "./process.ts";
-import { activityForNotification, type ActivityStage } from "./activity.ts";
-
-type Pending={resolve:(value:any)=>void;reject:(reason:Error)=>void;timer:NodeJS.Timeout};
-
-export class RepeatedFailureError extends Error {
-  readonly fingerprint: string;
-  constructor(fingerprint:string){super("Codex repeated the same failed command three times.");this.fingerprint=fingerprint;}
-}
-export class CodexBlockedError extends Error {}
-
-export class CodexSession {
-  readonly child: ChildProcessWithoutNullStreams;
-  readonly events=new EventEmitter();
-  private pending=new Map<number,Pending>();
-  private id=0;
-  private buffer="";
-  private failed:Error|null=null;
-  private commandFailures=new Map<string,number>();
-
-  constructor(child:ChildProcessWithoutNullStreams) {
-    this.child=child;
-    child.stderr.resume();
-    child.stdin.on("error",()=>this.fail(new Error("Codex transport closed.")));
-    child.stdout.on("data",chunk=>this.consume(chunk.toString()));
-    child.on("error",()=>this.fail(new Error("Codex could not start. Check the locally installed CLI.")));
-    child.on("close",()=>this.fail(new Error("Codex process stopped before completion.")));
-  }
-
-  static start(binary:string,workspace:string):CodexSession {
-    // Keep provider-owned local login, but never forward API/Git tokens into the agent.
-    const allowed=["PATH","HOME","USER","LOGNAME","SHELL","TMPDIR","LANG","LC_ALL","CODEX_HOME","HTTP_PROXY","HTTPS_PROXY","ALL_PROXY","NO_PROXY"];
-    const env=Object.fromEntries(allowed.filter(key=>process.env[key]!==undefined).map(key=>[key,process.env[key]]));
-    const args=["app-server","--listen","stdio://",
-      "-c",'permissions.dev-orchestrator.extends=":workspace"',
-      "-c",'permissions.dev-orchestrator.filesystem={":workspace_roots"={"."="write",".git"="write",".agents"="write",".codex"="read",".aws"="read"}}',
-      "-c","permissions.dev-orchestrator.network.enabled=false"];
-    return new CodexSession(spawn(binary,args,{cwd:workspace,env,detached:true,stdio:["pipe","pipe","pipe"]}));
-  }
-
-  async initialize():Promise<void> {
-    await this.request("initialize",{clientInfo:{name:"dev_orchestrator",title:"Dev Orchestrator",version:"0.1.0"},capabilities:{experimentalApi:true}});
-    this.send({method:"initialized",params:{}});
-  }
-  async authenticated():Promise<boolean> {
-    const result=await this.request("account/read",{refreshToken:false});
-    return result.account?.type==="chatgpt";
-  }
-
-  async run(workspace:string,prompt:string,model:string|undefined,signal?:AbortSignal,onProgress?:(stage:ActivityStage)=>Promise<void>):Promise<void> {
-    const thread=await this.request("thread/start",{cwd:workspace,approvalPolicy:"never",permissions:"dev-orchestrator",...(model?{model}:{})});
-    const threadId=thread.thread?.id;
-    if(!threadId)throw new Error("Codex returned no task thread.");
-    let onNotification:(message:any)=>void;
-    let onFailure:(error:Error)=>void;
-    let abort:()=>void;
-    let outcome:string|undefined;
-    let lastStage:ActivityStage|undefined;
-    let progressQueue=Promise.resolve();
-    let progressFailure:Error|undefined;
-    const completed=new Promise<void>((resolve,reject)=>{
-      onNotification=(message)=>{
-        if(message.params?.threadId===threadId) {
-          const stage=activityForNotification(message);
-          if(stage && stage!==lastStage) {
-            lastStage=stage;
-            progressQueue=progressQueue.then(()=>onProgress?.(stage));
-            void progressQueue.catch(error=>{
-              progressFailure=error instanceof Error?error:new Error("Progress delivery failed.");
-              this.fail(progressFailure);
-            });
-          }
-        }
-        if(message.method==="item/completed" && message.params?.threadId===threadId && message.params.item?.type==="agentMessage") {
-          try {const result=JSON.parse(message.params.item.text);if(["completed","blocked"].includes(result?.outcome))outcome=result.outcome;}catch{/* Wait for a valid structured final answer. */}
-        }
-        if(message.method==="turn/completed" && message.params?.threadId===threadId) {
-          if(outcome==="blocked")reject(new CodexBlockedError("Essential context is missing; the task is blocked."));
-          else if(message.params.turn?.status==="completed" && outcome==="completed")resolve();
-          else reject(new Error("Codex turn did not complete."));
-        }
-      };
-      onFailure=reject;
-      abort=()=>{this.stop();reject(new Error("Task stopped before lease expiration."));};
-      this.events.on("notification",onNotification);
-      this.events.once("failure",onFailure);
-      signal?.addEventListener("abort",abort,{once:true});
-      if(signal?.aborted)abort();
-    });
-    // Attach a rejection handler before turn/start to cover an early process exit.
-    completed.catch(()=>{});
-    try {
-      await this.request("turn/start",{threadId,cwd:workspace,approvalPolicy:"never",permissions:"dev-orchestrator",input:[{type:"text",text:prompt}],outputSchema:{type:"object",properties:{outcome:{type:"string",enum:["completed","blocked"]}},required:["outcome"],additionalProperties:false}});
-      await completed;
-      await progressQueue;
-      if(progressFailure)throw progressFailure;
-    } finally {
-      this.events.off("notification",onNotification!);this.events.off("failure",onFailure!);
-      signal?.removeEventListener("abort",abort!);
-    }
-  }
-
-  stop():void {stopProcess(this.child);this.fail(new Error("Codex stopped."));}
-
-  private request(method:string,params:unknown):Promise<any> {
-    if(this.failed)return Promise.reject(this.failed);
-    return new Promise((resolve,reject)=>{
-      const id=++this.id;
-      const timer=setTimeout(()=>{this.pending.delete(id);reject(new Error("Codex request timed out."));this.stop();},30_000);
-      this.pending.set(id,{resolve,reject,timer});this.send({id,method,params});
-    });
-  }
-  private send(message:unknown):void {if(!this.child.stdin.destroyed)this.child.stdin.write(JSON.stringify(message)+"\n");}
-  private consume(chunk:string):void {
-    this.buffer+=chunk;
-    if(this.buffer.length>1_048_576){this.fail(new Error("Codex message exceeded the size limit."));this.stop();return;}
-    let newline:number;
-    while((newline=this.buffer.indexOf("\n"))>=0) {
-      const line=this.buffer.slice(0,newline);this.buffer=this.buffer.slice(newline+1);
-      if(!line.trim())continue;
-      let message:any;
-      try{message=JSON.parse(line);}catch{this.fail(new Error("Invalid Codex protocol response."));this.stop();return;}
-      if(!message || typeof message!=="object" || Array.isArray(message)){this.fail(new Error("Invalid Codex protocol response."));this.stop();return;}
-      if(message.method==="item/completed") {
-        const item=message.params?.item;
-        if(item?.type==="commandExecution" && (typeof item.exitCode==="number" && item.exitCode!==0 || item.status==="failed")) {
-          const command=String(item.command??"");
-          const wrapped=command.trim().match(/^(?:\/[^\s]+\/)?(?:bash|zsh|sh)\s+-lc\s+(['"])([\s\S]*)\1$/);
-          const probe=(wrapped?.[2]??command).trim();
-          const unquoted=probe.replace(/"[^"\n]*"|'[^'\n]*'/g,"");
-          const expectedMiss=item.exitCode===1 && /^(?:rg|grep|test|\[)(?:\s|$)/.test(probe) && !/[;&|]/.test(unquoted);
-          if(!expectedMiss) {
-            const detail=(command+":"+String(item.exitCode)+":"+String(item.aggregatedOutput??"")).replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi,"<id>").replace(/\b\d+(?:\.\d+)?\s*(?:ms|s|seconds)\b/g,"<duration>");
-            const fingerprint=createHash("sha256").update(detail).digest("hex");
-            const count=(this.commandFailures.get(fingerprint)??0)+1;this.commandFailures.set(fingerprint,count);
-            if(count>=3){this.fail(new RepeatedFailureError(fingerprint));this.stop();return;}
-          }
-        }
-      }
-      if(message.method && message.id!==undefined) {
-        // The connector never auto-approves a broader permission or user-input request.
-        this.send({id:message.id,error:{code:-32000,message:"Required context or permission is unavailable; task blocked."}});
-        this.fail(new Error("Codex needs context or unsupported permissions."));this.stop();return;
-      }
-      if(message.id!==undefined) {
-        const pending=this.pending.get(message.id);
-        if(pending){clearTimeout(pending.timer);this.pending.delete(message.id);message.error?pending.reject(new Error("Codex rejected the configured request or sandbox.")):pending.resolve(message.result);}
-      } else if(message.method)this.events.emit("notification",message);
-    }
-  }
-  private fail(error:Error):void {
-    if(this.failed)return;
-    this.failed=error;
-    for(const pending of this.pending.values()){clearTimeout(pending.timer);pending.reject(error);}this.pending.clear();
-    this.events.emit("failure",error);
-  }
-}

package/src/config.ts

@@ -1,46 +0,0 @@
-import { lstat, readFile, mkdir, open, rename, unlink } from "node:fs/promises";
-import { dirname, isAbsolute } from "node:path";
-import { randomUUID } from "node:crypto";
-import type { Config } from "./types.ts";
-
-export function serverURL(value: string): string {
-  const url = new URL(value);
-  const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
-  if ((url.protocol !== "https:" && !(local && url.protocol === "http:")) || url.username || url.password || url.search || url.hash || url.pathname !== "/") throw new Error("Use an HTTPS server origin (loopback HTTP is allowed for development).");
-  return url.origin;
-}
-
-export async function loadConfig(path: string): Promise<Config> {
-  if (!isAbsolute(path)) throw new Error("Configuration path must be absolute.");
-  const info = await lstat(path);
-  if (!info.isFile() || info.isSymbolicLink() || (info.mode & 0o077) !== 0) throw new Error("Configuration must be a regular owner-only file (chmod 600).");
-  const config = JSON.parse(await readFile(path,"utf8"));
-  if (![1,2].includes(config.version) || typeof config.token !== "string" || !config.token) throw new Error("Invalid connector configuration.");
-  const server = serverURL(config.server);
-  if (config.version === 1) {
-    if (!Array.isArray(config.mappings)) throw new Error("Invalid connector configuration.");
-    console.warn("Legacy connector configuration detected. Local project mappings are ignored; bind projects in the web app.");
-  } else if ("mappings" in config) {
-    throw new Error("Invalid connector configuration.");
-  }
-  return {version:2,server,token:config.token,...(typeof config.codexBinary === "string"?{codexBinary:config.codexBinary}:{})};
-}
-
-export async function saveConfig(path: string, config: Config, exclusive = false): Promise<void> {
-  if (!isAbsolute(path)) throw new Error("Configuration path must be absolute.");
-  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-  if (!exclusive) {
-    try { await loadConfig(path); } catch (e) { if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e; }
-  }
-  if (exclusive) {
-    const file = await open(path,"wx",0o600);
-    try { await file.writeFile(JSON.stringify(config,null,2)); await file.sync(); } finally { await file.close(); }
-  } else {
-    const temporary = path + ".tmp-" + randomUUID();
-    const file = await open(temporary,"wx",0o600);
-    try {
-      await file.writeFile(JSON.stringify(config,null,2)); await file.sync();
-      await file.close(); await rename(temporary,path);
-    } catch (error) { await file.close().catch(()=>{}); await unlink(temporary).catch(()=>{}); throw error; }
-  }
-}

package/src/git-credential.ts

@@ -1,29 +0,0 @@
-import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { GitHubCredential } from "./types.ts";
-import { cleanGitEnv } from "./process.ts";
-
-export function validateGitHubCredential(value: unknown): asserts value is GitHubCredential {
-  if (!value || typeof value !== "object") throw new Error("GitHub authorization is unavailable.");
-  const credential=value as Partial<GitHubCredential>;
-  if (typeof credential.token!=="string" || !/^[A-Za-z0-9_-]+$/.test(credential.token) ||
-      typeof credential.expires_at!=="string" || !Number.isFinite(Date.parse(credential.expires_at)) || Date.parse(credential.expires_at)<=Date.now() ||
-      typeof credential.author_name!=="string" || !credential.author_name || credential.author_name.length>200 || /[\r\n]/.test(credential.author_name) ||
-      typeof credential.author_email!=="string" || !credential.author_email || credential.author_email.length>254 || /[\r\n]/.test(credential.author_email)) {
-    throw new Error("GitHub authorization is invalid or expired.");
-  }
-}
-
-export async function withGitHubCredential<T>(root:string, credential:GitHubCredential, operation:(env:NodeJS.ProcessEnv)=>Promise<T>):Promise<T> {
-  validateGitHubCredential(credential);
-  const directory=await mkdtemp(join(root,".github-auth-"));
-  try {
-    await chmod(directory,0o700);
-    const helper=join(directory,"askpass");
-    const script=`#!/bin/sh\ncase "$1" in\n  *sername*) printf '%s\\n' 'x-access-token' ;;\n  *assword*) printf '%s\\n' '${credential.token}' ;;\n  *) exit 1 ;;\nesac\n`;
-    await writeFile(helper,script,{encoding:"utf8",mode:0o700,flag:"wx"});
-    return await operation({...cleanGitEnv(),GIT_ASKPASS:helper,SSH_ASKPASS:helper,GIT_TERMINAL_PROMPT:"0"});
-  } finally {
-    await rm(directory,{recursive:true,force:true});
-  }
-}

package/src/journal.ts

@@ -1,36 +0,0 @@
-import { mkdir, open, readFile, rename, unlink, lstat } from "node:fs/promises";
-import { join, isAbsolute } from "node:path";
-import { randomUUID } from "node:crypto";
-import type { JournalState } from "./types.ts";
-
-export class Journal {
-  readonly root: string;
-  constructor(root: string) {
-    if (!isAbsolute(root)) throw new Error("Journal directory must be absolute.");
-    this.root = root;
-  }
-  async load(): Promise<JournalState | null> {
-    try {
-      const path = join(this.root,"active.json");
-      const stat = await lstat(path);
-      if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077)) throw new Error("Unsafe journal file.");
-      const state = JSON.parse(await readFile(path,"utf8"));
-      if (!state.lease?.id || !Number.isInteger(state.sequence)) throw new Error("Corrupt journal; manual recovery is required.");
-      return state;
-    } catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return null; throw error; }
-  }
-  async save(state: JournalState): Promise<void> {
-    await mkdir(this.root,{recursive:true,mode:0o700});
-    const info = await lstat(this.root);
-    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Unsafe journal directory.");
-    const temp = join(this.root,".journal-" + randomUUID());
-    const file = await open(temp,"wx",0o600);
-    try {
-      await file.writeFile(JSON.stringify(state)); await file.sync(); await file.close();
-      await rename(temp,join(this.root,"active.json"));
-    } catch (error) { await file.close().catch(()=>{}); await unlink(temp).catch(()=>{}); throw error; }
-  }
-  async clear(): Promise<void> {
-    await unlink(join(this.root,"active.json")).catch((e: NodeJS.ErrnoException) => { if (e.code !== "ENOENT") throw e; });
-  }
-}