@sweny-ai/core 0.1.175 → 0.1.177

package/dist/skills/github.js

@@ -4,11 +4,6 @@
  * Replaces: source-control/github.ts + issue-tracking/github-issues.ts
  * ~800 lines → ~120 lines
  */
-let branchPusher;
-/** Register (or clear, with `undefined`) the sweny-side branch pusher. */
-export function setBranchPusher(fn) {
-    branchPusher = fn;
-}
 class GitHubApiError extends Error {
     status;
     body;
@@ -19,8 +14,28 @@ class GitHubApiError extends Error {
         this.body = body;
     }
 }
+/**
+ * The REST base: `ctx.githubApiUrl` (the operator's GITHUB_API_URL, for GHES)
+ * or https://api.github.com. Only a plain https URL: no credentials, query or
+ * fragment, since the token goes to it.
+ */
+export function githubApiBase(apiUrl) {
+    if (!apiUrl)
+        return "https://api.github.com";
+    let u;
+    try {
+        u = new URL(apiUrl);
+    }
+    catch {
+        throw new Error(`[GitHub] GITHUB_API_URL is not a URL`);
+    }
+    if (u.protocol !== "https:" || u.username || u.password || u.search || u.hash) {
+        throw new Error(`[GitHub] GITHUB_API_URL is not a plain https URL`);
+    }
+    return `${u.origin}${u.pathname.replace(/\/+$/, "")}`;
+}
 async function gh(path, ctx, init) {
-    const res = await fetch(`https://api.github.com${path}`, {
+    const res = await fetch(`${githubApiBase(ctx.githubApiUrl)}${path}`, {
         ...init,
         headers: {
             Authorization: `token ${ctx.config.GITHUB_TOKEN}`,
@@ -34,6 +49,49 @@ async function gh(path, ctx, init) {
         throw new GitHubApiError(res.status, await res.text());
     return res.json();
 }
+/**
+ * Whether sweny may push the PR's head branch, from the API (#498). The agent
+ * names head and base, so head could be an existing integration branch
+ * ("release") that is neither base nor default. A head that does not exist
+ * remotely is pushed with an empty lease (it must still not exist). One that
+ * exists is pushed only when it is unprotected and already has an open PR from
+ * this repo into `base`, leased on the sha the API returned. Any API failure
+ * means no push.
+ */
+export async function headPushLease(repo, head, base, ctx) {
+    const branch = head.replace(/^refs\/heads\//, "");
+    const target = base.replace(/^refs\/heads\//, "");
+    const seg = branch.split("/").map(encodeURIComponent).join("/");
+    let info;
+    try {
+        info = (await gh(`/repos/${repo}/branches/${seg}`, ctx));
+    }
+    catch (err) {
+        if (err instanceof GitHubApiError && err.status === 404)
+            return { remoteSha: "" };
+        return { skip: `cannot check head ${branch} on ${repo}: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const sha = info?.commit?.sha;
+    if (typeof sha !== "string" || !/^[0-9a-f]{40}([0-9a-f]{24})?$/.test(sha)) {
+        return { skip: `cannot check head ${branch} on ${repo}: no branch sha in the API answer` };
+    }
+    if (info.protected !== false)
+        return { skip: `head ${branch} exists on ${repo} and is protected` };
+    const owner = repo.split("/")[0];
+    let open;
+    try {
+        open = await gh(`/repos/${repo}/pulls?head=${encodeURIComponent(`${owner}:${branch}`)}&base=${encodeURIComponent(target)}&state=open&per_page=1`, ctx);
+    }
+    catch (err) {
+        return {
+            skip: `cannot check open PRs for ${branch} on ${repo}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!Array.isArray(open) || open.length === 0) {
+        return { skip: `head ${branch} already exists on ${repo} with no open PR into ${target}` };
+    }
+    return { remoteSha: sha };
+}
 function isAlreadyExistsError(err) {
     if (!(err instanceof GitHubApiError) || err.status !== 422)
         return false;
@@ -187,15 +245,33 @@ export const github = {
                 // recommended `persist-credentials: false` checkout still ships the
                 // branch and the agent never holds a write token. Skipped unless the
                 // branch exists locally and origin is this repo; never forced.
-                if (branchPusher) {
-                    const push = await branchPusher({
-                        repo: input.repo,
-                        head: input.head,
-                        base: input.base ?? "main",
-                        token: ctx.config.GITHUB_TOKEN,
-                    });
-                    if (push.pushed)
-                        ctx.logger?.info?.(`  github_create_pr: pushed ${input.head} to origin`);
+                if (ctx.pushBranch) {
+                    // The default branch comes from the API, not the agent-written
+                    // checkout's origin/HEAD. Unknown means no push.
+                    let defaultBranch;
+                    try {
+                        const meta = (await gh(`/repos/${input.repo}`, ctx));
+                        if (typeof meta?.default_branch === "string")
+                            defaultBranch = meta.default_branch;
+                    }
+                    catch {
+                        // The pusher refuses without it; the PR request below reports the API error.
+                    }
+                    const lease = await headPushLease(input.repo, input.head, input.base ?? "main", ctx);
+                    const push = "skip" in lease
+                        ? { pushed: false, attempted: false, reason: lease.skip }
+                        : await ctx.pushBranch({
+                            repo: input.repo,
+                            head: input.head,
+                            base: input.base ?? "main",
+                            ...(defaultBranch ? { defaultBranch } : {}),
+                            remoteSha: lease.remoteSha,
+                            token: ctx.config.GITHUB_TOKEN,
+                        });
+                    if ("skip" in lease)
+                        ctx.logger?.warn?.(`  github_create_pr: not pushing: ${lease.skip}`);
+                    else if (push.pushed)
+                        ctx.logger?.info?.(`  github_create_pr: pushed ${input.head} to ${input.repo}`);
                     else if (push.attempted)
                         ctx.logger?.warn?.(`  github_create_pr: ${push.reason}; requesting the PR anyway`);
                     else

package/dist/startup-env.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The process environment as it was before sweny read any workspace file.
+ *
+ * The workspace is agent-writable, and its `.env` (cli/config-file.ts
+ * `loadDotenv`) may set any variable the real environment left unset. The
+ * privileged git push (skills/git-push.ts) must not take its PATH, proxy or CA
+ * settings, or the server it sends the token to, from a value the workspace
+ * introduced. This module is imported by config-file.ts, so the snapshot is
+ * taken when the module graph loads, before `loadDotenv()` runs.
+ *
+ * Node only.
+ */
+/** The environment captured at process startup, before any workspace file was read. */
+export declare function startupEnv(): Readonly<NodeJS.ProcessEnv>;
+/**
+ * The temp dir from the startup env. `os.tmpdir()` reads TMPDIR at call time,
+ * which a workspace `.env` can set; this never moves after startup.
+ */
+export declare function startupTmpdir(): string;
+/** Record that a workspace file (`.env`) set `key` in `process.env`. */
+export declare function markWorkspaceEnv(key: string): void;
+/** Test seam: forget that a workspace file set `key`. */
+export declare function unmarkWorkspaceEnv(key: string): void;
+/**
+ * The value of `key` the privileged path may use. From `process.env` itself
+ * (the CLI's run env) it is always the startup value. From a caller-built env
+ * it is the caller's value, unless a workspace file introduced the key (a copy
+ * of `process.env` taken after `loadDotenv`), which yields the startup value.
+ */
+export declare function trustedEnvValue(env: NodeJS.ProcessEnv, key: string): string | undefined;

package/dist/startup-env.js

@@ -0,0 +1,48 @@
+/**
+ * The process environment as it was before sweny read any workspace file.
+ *
+ * The workspace is agent-writable, and its `.env` (cli/config-file.ts
+ * `loadDotenv`) may set any variable the real environment left unset. The
+ * privileged git push (skills/git-push.ts) must not take its PATH, proxy or CA
+ * settings, or the server it sends the token to, from a value the workspace
+ * introduced. This module is imported by config-file.ts, so the snapshot is
+ * taken when the module graph loads, before `loadDotenv()` runs.
+ *
+ * Node only.
+ */
+import { tmpdir } from "node:os";
+const SNAPSHOT = Object.freeze({ ...process.env });
+/** os.tmpdir() as resolved from the startup env (TMPDIR, TEMP, TMP), before any workspace file was read. */
+const TMP = tmpdir();
+/** Variable names a workspace file wrote into `process.env` after startup. */
+const introduced = new Set();
+/** The environment captured at process startup, before any workspace file was read. */
+export function startupEnv() {
+    return SNAPSHOT;
+}
+/**
+ * The temp dir from the startup env. `os.tmpdir()` reads TMPDIR at call time,
+ * which a workspace `.env` can set; this never moves after startup.
+ */
+export function startupTmpdir() {
+    return TMP;
+}
+/** Record that a workspace file (`.env`) set `key` in `process.env`. */
+export function markWorkspaceEnv(key) {
+    introduced.add(key);
+}
+/** Test seam: forget that a workspace file set `key`. */
+export function unmarkWorkspaceEnv(key) {
+    introduced.delete(key);
+}
+/**
+ * The value of `key` the privileged path may use. From `process.env` itself
+ * (the CLI's run env) it is always the startup value. From a caller-built env
+ * it is the caller's value, unless a workspace file introduced the key (a copy
+ * of `process.env` taken after `loadDotenv`), which yields the startup value.
+ */
+export function trustedEnvValue(env, key) {
+    if (env === process.env || introduced.has(key))
+        return SNAPSHOT[key];
+    return env[key];
+}

package/dist/types.d.ts

@@ -12,7 +12,43 @@ export interface ToolContext {
     config: Record<string, string>;
     /** Structured logger */
     logger: Logger;
-}
+    /** The run's working directory (`ExecuteOptions.cwd`, else `process.cwd()`). */
+    cwd?: string;
+    /**
+     * A staged or dry run: no side effects. The executor refuses every
+     * non-`read` tool before its handler runs.
+     */
+    staged?: boolean;
+    /**
+     * Pushes a PR's head branch from the sweny process (#473), bound to this
+     * run's checkout. Set by the Node executor; absent in the browser build,
+     * where `github_create_pr` only calls the API.
+     */
+    pushBranch?: BranchPusher;
+    /**
+     * The operator's GITHUB_API_URL (GHES), read through the startup env
+     * snapshot by the Node executor. Absent means https://api.github.com.
+     */
+    githubApiUrl?: string;
+}
+/** The sweny-side head-branch push behind `github_create_pr` (#473). Never throws. */
+export type BranchPusher = (opts: {
+    repo: string;
+    head: string;
+    base: string;
+    /** The repo's default branch from the GitHub API; without it nothing is pushed. */
+    defaultBranch?: string;
+    /**
+     * The head branch's sha on the remote when it was checked through the API,
+     * or "" when it did not exist. The push leases on it. Without it nothing is pushed.
+     */
+    remoteSha?: string;
+    token?: string;
+}) => Promise<{
+    pushed: boolean;
+    attempted: boolean;
+    reason?: string;
+}>;
 /**
  * Side-effect class of a tool. `"read"` only reads. `"write"` can change
  * something outside the run: create, update, delete, post, send, invoke.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.175",
+  "version": "0.1.177",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"