symbio 0.5.0 → 0.7.0

package/dist/server/remote.js

@@ -1,7 +1,7 @@
 // Actions agents take through connections (SSH commands and uploads, git push/pull,
-// GitHub API). Symbio runs them itself with credentials from the vault — agents
-// only see results. Connections set to "ask" queue an approval for the human; the
-// result is delivered to the agent as a message once approved.
+// GitHub and Azure DevOps APIs). Symbio runs them itself with credentials from the
+// vault — agents only see results. Connections set to "ask" queue an approval for
+// the human; the result is delivered to the agent as a message once approved.
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { promises as fs, existsSync, realpathSync } from "node:fs";
@@ -28,13 +28,16 @@ export class RemoteOps {
     }
     describeFor(project) {
         const list = this.enabled(project);
-        if (list.length === 0)
-            return "This project has no connections. If the work needs GitHub or a server, tell the human to add one in the project's sidebar (Connections).";
+        if (list.length === 0) {
+            return "This project has no connections. If the work needs GitHub, Azure DevOps or a server, tell the human to add one in the project's Settings (Connections).";
+        }
         return list
             .map(({ conn, link }) => {
             const what = conn.type === "github"
                 ? `GitHub${conn.account ? ` account ${conn.account}` : ""} — git_push, git_pull, github_api`
-                : `server ${conn.username}@${conn.host} — remote_exec, remote_upload`;
+                : conn.type === "azure"
+                    ? `Azure DevOps organization ${conn.organization}${conn.account ? ` (as ${conn.account})` : ""} — git_push, git_pull, azure_devops_api`
+                    : `server ${conn.username}@${conn.host} — remote_exec, remote_upload`;
             return `- "${conn.name}": ${what} (${link.policy === "ask" ? "each action needs the human's approval" : "allowed without approval"})`;
         })
             .join("\n");
@@ -43,7 +46,7 @@ export class RemoteOps {
     async request(project, agent, action, reason) {
         const { conn, link } = this.resolve(project, action.connectionId, action.kind);
         const summary = this.summarize(conn, action, agent);
-        const readOnly = action.kind === "github_api" && action.method.toUpperCase() === "GET";
+        const readOnly = (action.kind === "github_api" || action.kind === "azure_devops_api") && action.method.toUpperCase() === "GET";
         if (link.policy === "allow" || readOnly) {
             return this.execute(project, agent, conn, action, summary, reason);
         }
@@ -106,9 +109,17 @@ export class RemoteOps {
             const names = this.enabled(project).map(({ conn }) => conn.name).join(", ") || "none";
             throw new Error(`No connection "${connectionRef}" in this project. Available: ${names}.`);
         }
-        const needs = kind.startsWith("remote_") ? "server" : "github";
-        if (found.conn.type !== needs)
-            throw new Error(`"${found.conn.name}" is a ${found.conn.type} connection; ${kind} needs a ${needs} connection.`);
+        const needs = kind.startsWith("remote_")
+            ? ["server"]
+            : kind === "github_api"
+                ? ["github"]
+                : kind === "azure_devops_api"
+                    ? ["azure"]
+                    : ["github", "azure"]; // git_push / git_pull
+        if (!needs.includes(found.conn.type)) {
+            const label = (t) => (t === "azure" ? "Azure DevOps" : t === "github" ? "GitHub" : "server");
+            throw new Error(`"${found.conn.name}" is a ${label(found.conn.type)} connection; ${kind} needs a ${needs.map(label).join(" or ")} connection.`);
+        }
         return found;
     }
     summarize(conn, a, agent) {
@@ -123,6 +134,8 @@ export class RemoteOps {
                 return `git pull ${a.remote ?? "origin"} ${a.branch ?? "(current branch)"} into ${agent.name}'s workspace using ${conn.name}`;
             case "github_api":
                 return `GitHub API ${a.method.toUpperCase()} ${a.path} using ${conn.name}`;
+            case "azure_devops_api":
+                return `Azure DevOps API ${a.method.toUpperCase()} ${a.path} using ${conn.name}`;
         }
     }
     async execute(project, agent, conn, a, summary, reason) {
@@ -163,12 +176,11 @@ export class RemoteOps {
             }
             case "git_push":
             case "git_pull": {
-                const token = await this.connections.githubToken(conn);
+                const gitConn = conn;
+                const token = await this.connections.githubToken(gitConn);
                 const remote = a.remote ?? "origin";
                 const url = remote.startsWith("https://") ? remote : await gitOut(agent.directory, ["remote", "get-url", remote]);
-                if (!/^https:\/\/github\.com\//i.test(url)) {
-                    throw new Error(`The remote must be a GitHub HTTPS URL (got ${url || "nothing"}). Add one with: git remote add origin https://github.com/<owner>/<repo>.git`);
-                }
+                const auth = gitAuth(gitConn, url, token);
                 const branch = a.branch ?? (await gitOut(agent.directory, ["rev-parse", "--abbrev-ref", "HEAD"]));
                 // The agent controls this repository, so its config and hooks are untrusted: a hook
                 // would see the token, a proxy or URL rewrite would send it elsewhere.
@@ -177,7 +189,7 @@ export class RemoteOps {
                 const safe = ["-c", `core.hooksPath=${noHooks}`, "-c", "http.proxy=", "-c", "http.sslVerify=true", "-c", "credential.helper="];
                 // The token goes in an HTTP header via environment-only git config: never in
                 // the command line, the repo config or the agent's view.
-                const header = `Authorization: Basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}`;
+                const { headerKey, header } = auth;
                 const git = (args, withToken) => run("git", [...safe, ...args], {
                     cwd: agent.directory,
                     windowsHide: true,
@@ -185,9 +197,7 @@ export class RemoteOps {
                     env: {
                         ...process.env,
                         GIT_TERMINAL_PROMPT: "0",
-                        ...(withToken
-                            ? { GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: "http.https://github.com/.extraheader", GIT_CONFIG_VALUE_0: header }
-                            : {}),
+                        ...(withToken ? { GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: headerKey, GIT_CONFIG_VALUE_0: header } : {}),
                     },
                 }).catch((err) => {
                     throw new Error(scrub(String(err.stderr || err.message), token));
@@ -201,8 +211,11 @@ export class RemoteOps {
                 const merged = await git(["merge", "--no-edit", "FETCH_HEAD"], false);
                 return scrub(`${fetched.stdout}${fetched.stderr}${merged.stdout}${merged.stderr}`.trim() || "done", token);
             }
-            case "github_api": {
-                const data = await this.connections.githubRequest(conn, a.method.toUpperCase(), a.path, a.body);
+            case "github_api":
+            case "azure_devops_api": {
+                const data = a.kind === "github_api"
+                    ? await this.connections.githubRequest(conn, a.method.toUpperCase(), a.path, a.body)
+                    : await this.connections.azureRequest(conn, a.method.toUpperCase(), a.path, a.body);
                 const text = JSON.stringify(data, null, 2) ?? "(no content)";
                 return text.length > 20_000 ? `${text.slice(0, 20_000)}\n… (truncated)` : text;
             }
@@ -258,7 +271,7 @@ export async function refuseRiskyGitConfig(dir) {
         .filter(([scope, key]) => (scope === "local" || scope === "worktree") && key && RISKY_GIT_CONFIG.some((re) => re.test(key.toLowerCase())))
         .map(([, key]) => key);
     if (risky.length) {
-        throw new Error(`Refusing to use GitHub credentials: this repository's git config sets ${risky.join(", ")}, which could redirect or capture them. Remove ${risky.length > 1 ? "these settings" : "it"} (git config --unset <name>) and try again.`);
+        throw new Error(`Refusing to use the connection's credentials: this repository's git config sets ${risky.join(", ")}, which could redirect or capture them. Remove ${risky.length > 1 ? "these settings" : "it"} (git config --unset <name>) and try again.`);
     }
 }
 async function gitOut(cwd, args) {
@@ -266,6 +279,35 @@ async function gitOut(cwd, args) {
     return stdout.trim();
 }
 function scrub(text, secret) {
-    const b64 = Buffer.from(`x-access-token:${secret}`).toString("base64");
-    return text.split(secret).join("***").split(b64).join("***");
+    let out = text.split(secret).join("***");
+    for (const user of ["x-access-token:", ":"])
+        out = out.split(Buffer.from(`${user}${secret}`).toString("base64")).join("***");
+    return out;
+}
+/**
+ * How to send a connection's token to a git remote, after checking the remote belongs to it:
+ * a GitHub HTTPS URL for GitHub; for Azure DevOps, a dev.azure.com (or older visualstudio.com)
+ * URL of the connection's own organization, so its token never goes to someone else's.
+ */
+export function gitAuth(conn, url, token) {
+    if (conn.type === "github") {
+        if (!/^https:\/\/github\.com\//i.test(url)) {
+            throw new Error(`The remote must be a GitHub HTTPS URL (got ${url || "nothing"}). Add one with: git remote add origin https://github.com/<owner>/<repo>.git`);
+        }
+        return { headerKey: "http.https://github.com/.extraheader", header: `Authorization: Basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}` };
+    }
+    const devAzure = /^https:\/\/(?:[^@/]+@)?dev\.azure\.com\/([^/]+)\//i.exec(url);
+    const legacy = /^https:\/\/(?:[^@/]+@)?([^./]+)\.visualstudio\.com\//i.exec(url);
+    if (!devAzure && !legacy) {
+        throw new Error(`The remote must be an Azure DevOps HTTPS URL (got ${url || "nothing"}). ` +
+            (/^git@|^ssh:/i.test(url)
+                ? "It's an SSH remote; switch it to HTTPS: git remote set-url origin https://dev.azure.com/<organization>/<project>/_git/<repository>"
+                : "Add one with: git remote add origin https://dev.azure.com/<organization>/<project>/_git/<repository>"));
+    }
+    const org = decodeURIComponent((devAzure ?? legacy)[1]);
+    if (org.toLowerCase() !== conn.organization.toLowerCase()) {
+        throw new Error(`This remote belongs to the Azure DevOps organization "${org}", but "${conn.name}" is for "${conn.organization}". Use a connection for "${org}".`);
+    }
+    const host = devAzure ? "https://dev.azure.com/" : `https://${legacy[1]}.visualstudio.com/`;
+    return { headerKey: `http.${host}.extraheader`, header: `Authorization: Basic ${Buffer.from(`:${token}`).toString("base64")}` };
 }

package/dist/server/self-update.js

@@ -0,0 +1,254 @@
+// Keeping Symbio up to date: checks npm for a newer version and, when the human allows it,
+// updates while the team is idle. The install itself happens in bin/update-runner.mjs, a separate
+// process that waits for Symbio to exit (OpenCode and native modules lock their files while
+// running on Windows), installs, puts the old version back if that fails, and starts Symbio again.
+import { spawn } from "node:child_process";
+import { existsSync, promises as fs, realpathSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+/** A global npm install lives in <prefix>/node_modules/symbio (lib/node_modules on Unix); anything else, like `npm link` to a clone, is a development copy. */
+export function installInfo(root = packageRoot) {
+    const real = (() => {
+        try {
+            return realpathSync(root);
+        }
+        catch {
+            return root;
+        }
+    })();
+    const nodeModules = path.dirname(real);
+    if (path.basename(nodeModules) !== "node_modules" || existsSync(path.join(real, ".git")))
+        return { kind: "dev", root: real, prefix: null };
+    const prefix = process.platform === "win32" ? path.dirname(nodeModules) : path.dirname(path.dirname(nodeModules));
+    return { kind: "npm", root: real, prefix };
+}
+/** 1 if a > b, -1 if a < b, 0 if equal. Pre-releases ("0.3.0-beta.1") sort before their release. */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [main, pre] = v.replace(/^v/, "").split("-", 2);
+        return { nums: main.split(".").map((n) => Number(n) || 0), pre: pre ?? null };
+    };
+    const x = parse(a);
+    const y = parse(b);
+    for (let i = 0; i < 3; i++)
+        if ((x.nums[i] ?? 0) !== (y.nums[i] ?? 0))
+            return (x.nums[i] ?? 0) > (y.nums[i] ?? 0) ? 1 : -1;
+    if (x.pre === y.pre)
+        return 0;
+    if (x.pre === null)
+        return 1;
+    if (y.pre === null)
+        return -1;
+    return x.pre > y.pre ? 1 : -1;
+}
+// Overridable for tests (a local registry and package file); never set in normal use.
+const REGISTRY = (process.env.SYMBIO_UPDATE_REGISTRY ?? "https://registry.npmjs.org").replace(/\/+$/, "");
+/** The version npm installs as `symbio@latest`. */
+export async function latestVersion() {
+    const res = await fetch(`${REGISTRY}/symbio/latest`, { signal: AbortSignal.timeout(15_000), headers: { accept: "application/json" } });
+    if (!res.ok)
+        throw new Error(`npm registry answered ${res.status}`);
+    const data = (await res.json());
+    if (!data.version)
+        throw new Error("npm registry gave no version");
+    return data.version;
+}
+/** Changelog entries newer than `current`, from the latest version's CHANGELOG.md (best effort). */
+export async function changesSince(current, latest) {
+    const url = process.env.SYMBIO_UPDATE_CHANGELOG ?? `https://raw.githubusercontent.com/linkzy/symbio/v${latest}/CHANGELOG.md`;
+    const res = await fetch(url, { signal: AbortSignal.timeout(15_000) }).catch(() => null);
+    if (!res?.ok)
+        return [];
+    return parseChangelog(await res.text()).filter((s) => compareVersions(s.version, current) > 0);
+}
+export function parseChangelog(text) {
+    const out = [];
+    let section = null;
+    for (const line of text.replace(/\r/g, "").split("\n")) {
+        const head = /^## \[(\d+\.\d+\.\d+[^\]]*)\]/.exec(line);
+        if (head) {
+            section = { version: head[1], items: [] };
+            out.push(section);
+        }
+        else if (/^## /.test(line))
+            section = null;
+        else if (section && /^- /.test(line))
+            section.items.push(line.slice(2).trim());
+        else if (section && /^\s+\S/.test(line) && section.items.length)
+            section.items[section.items.length - 1] += ` ${line.trim()}`;
+    }
+    return out;
+}
+const CHECK_EVERY_MS = 6 * 60 * 60_000;
+const TICK_MS = 5 * 60_000;
+export const QUIET_MS = 10 * 60_000; // the team must have been quiet this long before an automatic update
+const FAILED_PAUSE_MS = 24 * 60 * 60_000; // after a failed update, don't retry the same version for a day
+export class SelfUpdate {
+    host;
+    latest = null;
+    checkedAt = null;
+    error = null;
+    notes = [];
+    mode = "auto";
+    skip = null;
+    lastResult = null;
+    applying = false;
+    timer = null;
+    settingsFile;
+    resultFile;
+    install;
+    constructor(host, install = installInfo()) {
+        this.host = host;
+        this.install = install;
+        this.settingsFile = path.join(host.home, "updates.json");
+        this.resultFile = path.join(host.home, "update-result.json");
+    }
+    async load() {
+        const settings = JSON.parse(await fs.readFile(this.settingsFile, "utf8").catch(() => "{}"));
+        if (settings.mode === "auto" || settings.mode === "notify" || settings.mode === "off")
+            this.mode = settings.mode;
+        this.skip = settings.skip ?? null;
+        this.lastResult = JSON.parse(await fs.readFile(this.resultFile, "utf8").catch(() => "null"));
+        // The runner wrote this before starting us again: tell the humans once.
+        if (this.lastResult && !this.lastResult.seen) {
+            const r = this.lastResult;
+            if (r.ok)
+                await this.host.announce(`Symbio was updated from ${r.from} to ${r.to}.`).catch(() => { });
+            else {
+                await this.host.announce(`Symbio couldn't update to ${r.to} and is still on ${this.host.version}: ${r.error}`).catch(() => { });
+                this.skip = { version: r.to, until: Date.now() + FAILED_PAUSE_MS };
+                await this.saveSettings();
+            }
+            r.seen = true;
+            await fs.writeFile(this.resultFile, JSON.stringify(r, null, 2)).catch(() => { });
+        }
+    }
+    start() {
+        void this.check().catch(() => { });
+        this.timer ??= setInterval(() => void this.tick().catch((err) => console.error("[update]", err.message)), TICK_MS);
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    state() {
+        const available = !!this.latest && compareVersions(this.latest, this.host.version) > 0;
+        return {
+            current: this.host.version,
+            latest: this.latest,
+            available,
+            checkedAt: this.checkedAt,
+            error: this.error,
+            mode: this.mode,
+            install: this.install.kind,
+            busy: this.host.busy(),
+            waiting: available ? this.blocker(false) : null,
+            notes: this.notes,
+            lastResult: this.lastResult,
+        };
+    }
+    async setMode(mode) {
+        this.mode = mode;
+        await this.saveSettings();
+    }
+    async check() {
+        if (this.mode === "off" && this.checkedAt)
+            return this.state();
+        try {
+            this.latest = await latestVersion();
+            this.error = null;
+            this.notes = compareVersions(this.latest, this.host.version) > 0 ? await changesSince(this.host.version, this.latest) : [];
+        }
+        catch (err) {
+            this.error = `Couldn't check for updates: ${err.message}`;
+        }
+        this.checkedAt = Date.now();
+        return this.state();
+    }
+    /** Why the update can't be applied now (null = it can). `forced`: the human asked, so only hard blockers count. */
+    blocker(forced) {
+        if (this.install.kind === "dev")
+            return "This Symbio runs from a development folder; update it with git pull, npm install and npm run build.";
+        if (this.applying)
+            return "Already updating.";
+        if (!forced && this.mode === "notify")
+            return "Updates are set to notify only: update from Settings or with `sym update`.";
+        if (!forced && this.mode === "off")
+            return "Automatic updates are off: update from Settings or with `sym update`.";
+        if (!forced && this.skip && this.latest === this.skip.version && Date.now() < this.skip.until)
+            return `The update to ${this.skip.version} failed recently; it will be retried tomorrow.`;
+        if (!forced && this.host.remoteActive())
+            return "Remote access is on (updating would end it); waiting until it's off.";
+        if (!forced) {
+            const busy = this.host.busy();
+            if (busy)
+                return `Waiting for the team to be idle (${busy}).`;
+        }
+        return null;
+    }
+    /** Automatic updates: check now and then; apply when allowed and the team has been quiet. */
+    async tick() {
+        if (this.mode === "off" || this.install.kind === "dev")
+            return;
+        if (!this.checkedAt || Date.now() - this.checkedAt > CHECK_EVERY_MS)
+            await this.check();
+        const s = this.state();
+        if (s.available && this.mode === "auto" && !this.blocker(false))
+            await this.apply(false);
+    }
+    /**
+     * Hands over to the runner and stops Symbio. `forced` (the human asked): applies even with
+     * agents working (they're interrupted and resumed after the restart).
+     */
+    async apply(forced) {
+        if (!this.latest || compareVersions(this.latest, this.host.version) <= 0)
+            await this.check();
+        if (!this.latest || compareVersions(this.latest, this.host.version) <= 0)
+            throw new Error(`Symbio ${this.host.version} is up to date.`);
+        const blocked = this.blocker(forced);
+        if (blocked)
+            throw new Error(blocked);
+        this.applying = true;
+        const to = this.latest;
+        try {
+            await this.host.backup().catch((err) => console.error("[update] backup failed:", err.message));
+            await this.host.announce(`Symbio is updating from ${this.host.version} to ${to}; it'll be back in a minute or two.`).catch(() => { });
+            await this.runRunner({ waitPid: process.pid, to, start: true });
+        }
+        catch (err) {
+            this.applying = false;
+            throw err;
+        }
+        setTimeout(() => void this.host.shutdown(), 300);
+        return `Updating to ${to}: Symbio restarts in a minute or two.`;
+    }
+    /** Starts the runner from a copy in the temp folder (npm replaces the package folder). */
+    async runRunner(opts) {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "symbio-update-"));
+        const runner = path.join(dir, "update-runner.mjs");
+        await fs.copyFile(path.join(this.install.root, "bin", "update-runner.mjs"), runner);
+        const job = path.join(dir, "job.json");
+        await fs.writeFile(job, JSON.stringify({
+            waitPid: opts.waitPid,
+            prefix: this.install.prefix,
+            spec: process.env.SYMBIO_UPDATE_SPEC ?? `symbio@${opts.to}`,
+            from: this.host.version,
+            to: opts.to,
+            root: this.install.root,
+            home: this.host.home,
+            port: this.host.port,
+            start: opts.start,
+            resultFile: this.resultFile,
+            logFile: path.join(this.host.home, "logs", "update.log"),
+        }));
+        const child = spawn(process.execPath, [runner, job], { detached: true, stdio: "ignore", windowsHide: true });
+        child.unref();
+    }
+    async saveSettings() {
+        await fs.mkdir(path.dirname(this.settingsFile), { recursive: true });
+        await fs.writeFile(this.settingsFile, JSON.stringify({ mode: this.mode, skip: this.skip }, null, 2));
+    }
+}

package/dist/server/team.js

@@ -229,6 +229,33 @@ export class Team {
             this.recycling = false;
         }
     }
+    /**
+     * What would be interrupted by a restart right now (null = nothing): an agent working or waiting
+     * for an answer, a permission request, or activity in the last `quietMs`.
+     */
+    busyReason(quietMs) {
+        const now = Date.now();
+        for (const project of this.store.list()) {
+            for (const agent of project.agents.filter(active)) {
+                if (agent.status === "busy" || agent.status === "stuck")
+                    return `${agent.name} in ${project.name} is working`;
+                if (agent.status === "waiting")
+                    return `${agent.name} in ${project.name} is waiting for an answer`;
+                if (now - agent.lastActivity < quietMs)
+                    return `${agent.name} in ${project.name} was active in the last ${Math.round(quietMs / 60_000)} minutes`;
+            }
+        }
+        if (this.permissions.size)
+            return "a permission request is waiting for an answer";
+        return null;
+    }
+    /** A note for the human in every project's Messages (e.g. "Symbio was updated"). */
+    async announce(text) {
+        for (const project of this.store.list()) {
+            await this.log(project, { from: "symbio", to: "human", kind: "system", text });
+            bus.publish({ type: "project.updated", projectId: project.id });
+        }
+    }
     stopWatchdog() {
         if (this.watchdog)
             clearInterval(this.watchdog);

package/dist/server/tools.js

@@ -330,20 +330,20 @@ const remoteUpload = {
     run: ({ connection, local_path, remote_path, reason }, { team, project, agent }) => team.remote.request(project, agent, { kind: "remote_upload", connectionId: String(connection), localPath: String(local_path), remotePath: String(remote_path) }, String(reason)),
 };
 const gitFields = {
-    connection: str("GitHub connection name"),
-    remote: str("Remote name or https://github.com/… URL (default: origin)"),
+    connection: str("GitHub or Azure DevOps connection name"),
+    remote: str("Remote name or HTTPS URL (github.com, dev.azure.com) (default: origin)"),
     branch: str("Branch (default: your current branch)"),
     reason: reasonField,
 };
 const gitPush = {
     name: "git_push",
-    description: "Push committed work from your working folder to GitHub (the token is applied by Symbio; plain `git push` has no credentials).",
+    description: "Push committed work from your working folder to GitHub or Azure DevOps (the token is applied by Symbio; plain `git push` may have no credentials).",
     inputSchema: obj(gitFields, ["connection", "reason"]),
     run: ({ connection, remote, branch, reason }, { team, project, agent }) => team.remote.request(project, agent, { kind: "git_push", connectionId: String(connection), remote: remote ? String(remote) : null, branch: branch ? String(branch) : null }, String(reason)),
 };
 const gitPull = {
     name: "git_pull",
-    description: "Pull from GitHub into your working folder (merge, no rebase).",
+    description: "Pull from GitHub or Azure DevOps into your working folder (merge, no rebase).",
     inputSchema: obj(gitFields, ["connection", "reason"]),
     run: ({ connection, remote, branch, reason }, { team, project, agent }) => team.remote.request(project, agent, { kind: "git_pull", connectionId: String(connection), remote: remote ? String(remote) : null, branch: branch ? String(branch) : null }, String(reason)),
 };
@@ -354,11 +354,29 @@ const githubApi = {
         connection: str("GitHub connection name"),
         method: { type: "string", enum: ["GET", "POST", "PATCH", "PUT", "DELETE"] },
         path: str("API path, e.g. /user/repos"),
-        body: { type: "object", description: "JSON body for POST/PATCH/PUT" },
+        // Some endpoints take a list (e.g. Azure DevOps ref updates), others an object.
+        body: { anyOf: [{ type: "object" }, { type: "array" }], description: "JSON body for POST/PATCH/PUT (an object, or a list where the API expects one)" },
         reason: reasonField,
     }, ["connection", "method", "path", "reason"]),
     run: ({ connection, method, path, body, reason }, { team, project, agent }) => team.remote.request(project, agent, { kind: "github_api", connectionId: String(connection), method: String(method), path: String(path), body }, String(reason)),
 };
+const azureDevopsApi = {
+    name: "azure_devops_api",
+    description: "Call the Azure DevOps REST API of the connection's organization. The path is relative to https://dev.azure.com/<organization>/ " +
+        "and api-version is added if missing. E.g. GET <project>/_apis/git/repositories to find a repository's id; " +
+        "POST <project>/_apis/git/repositories/<repo>/pullrequests with {sourceRefName: 'refs/heads/<branch>', targetRefName: " +
+        "'refs/heads/main', title, description} to open a pull request (push the branch first with git_push); " +
+        "GET <project>/_apis/git/repositories/<repo>/pullrequests?searchCriteria.status=active to list them. Read-only GET calls never need approval.",
+    inputSchema: obj({
+        connection: str("Azure DevOps connection name"),
+        method: { type: "string", enum: ["GET", "POST", "PATCH", "PUT", "DELETE"] },
+        path: str("Path inside the organization, e.g. MyProject/_apis/git/repositories"),
+        // Some endpoints take a list (e.g. Azure DevOps ref updates), others an object.
+        body: { anyOf: [{ type: "object" }, { type: "array" }], description: "JSON body for POST/PATCH/PUT (an object, or a list where the API expects one)" },
+        reason: reasonField,
+    }, ["connection", "method", "path", "reason"]),
+    run: ({ connection, method, path, body, reason }, { team, project, agent }) => team.remote.request(project, agent, { kind: "azure_devops_api", connectionId: String(connection), method: String(method), path: String(path), body }, String(reason)),
+};
 // ---- rules register (only when the project keeps one)
 function registerOn(project) {
     if (!project.rulesRegister)
@@ -460,6 +478,7 @@ const COMMON = [
     gitPush,
     gitPull,
     githubApi,
+    azureDevopsApi,
     sendMessage,
     askHuman,
     listTeam,

package/dist/server/updates.js

@@ -74,6 +74,23 @@ export const AGENT_UPDATES = [
             "leave reviewing many images to a helper. If a conversation still becomes too large, Symbio moves that agent to a fresh " +
             "session with a handoff note instead of trying other models.",
     },
+    {
+        id: "2026-11-06-credentials",
+        text: "Credentials, clarified: the old rule \"never look for credentials or put secrets in commands\" was meant for Symbio's own " +
+            "secrets (its vault, connections, SSH keys), and it stopped agents from doing legitimate work. Now: Symbio's secrets stay " +
+            "off-limits (use connections only through the tools). The project's own credentials (connection strings, .env, Web.config…) " +
+            "and credentials the human gives you may be used for the task, e.g. querying a database the work needs. Don't spread them: " +
+            "never put one into anything committed or shared (new files, docs, the rules register, the plan, messages to other agents), " +
+            "and prefer commands that read it from the config file. If the human says a system is a read-only mirror or production, only " +
+            "read from it unless they explicitly OK changes. If you refused such a task before, you can do it now.",
+    },
+    {
+        id: "2026-11-06-azure-devops",
+        text: "Azure DevOps connections: the human can now add an Azure DevOps organization (with a personal access token) in Settings and " +
+            "enable it per project. git_push and git_pull work with it (HTTPS remotes of that organization; SSH remotes must be switched to " +
+            "HTTPS), and the new azure_devops_api tool calls its REST API, e.g. to open a pull request after pushing the branch. Reading " +
+            "(GET) never needs approval. If a push or a pull request failed for lack of credentials, ask the human to add the connection.",
+    },
 ];
 /** Entries a project hasn't been told about yet. */
 export function unseenUpdates(seen) {