@ouro.bot/cli 0.1.0-alpha.922 → 0.1.0-alpha.924

package/dist/senses/shepherd/surface.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHEPHERD_UUID = void 0;
+exports.resolveExistingLocalOwner = resolveExistingLocalOwner;
+exports.localShepherdFriendStore = localShepherdFriendStore;
+exports.machineShepherdHost = machineShepherdHost;
+exports.listShepherdTargets = listShepherdTargets;
+exports.validateShepherdTarget = validateShepherdTarget;
+exports.authorizedShepherdTargets = authorizedShepherdTargets;
+const path = __importStar(require("node:path"));
+const friends_1 = require("@ouro.bot/friends");
+const identity_1 = require("../../heart/identity");
+const runtime_credentials_1 = require("../../heart/runtime-credentials");
+const shepherd_config_1 = require("../../heart/shepherd-config");
+const tools_shepherd_1 = require("../../repertoire/tools-shepherd");
+const host_1 = require("./host");
+const runtime_1 = require("../../nerves/runtime");
+exports.SHEPHERD_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Resolve the CLI's local identity, but forbid the resolver's first-encounter creation/promotion. */
+async function resolveExistingLocalOwner(store, username = (0, friends_1.machineOwnerUsername)()) {
+    if (!username)
+        throw new Error("local machine owner identity is unavailable");
+    let existing = await store.findByExternalId("local", username);
+    if (!existing) {
+        const matches = (store.listAll ? await store.listAll() : []).filter(friend => friend.externalIds.some(identity => identity.provider === "local" && identity.externalId.startsWith(`${username}@`)));
+        if (matches.length > 1)
+            throw new Error("local-family linking is ambiguous; authorized owner setup is required");
+        existing = matches[0] ?? null;
+    }
+    if (!existing || existing.trustLevel !== "family" || existing.admissionState === "revoked") {
+        throw new Error(`existing local-family linking is missing for OS user ${username}; authorized owner setup is required`);
+    }
+    // Snapshot lookup prevents FriendResolver from creating on a transient search failure or
+    // migrating an identity as a side effect. The same resolver/channel path still produces context.
+    const snapshot = existing;
+    const readonlyLookup = Object.create(store);
+    readonlyLookup.findByExternalId = async () => snapshot;
+    return (await new friends_1.FriendResolver(readonlyLookup, {
+        provider: "local", externalId: username, displayName: username, channel: "cli",
+    }).resolve()).friend.id;
+}
+function localShepherdFriendStore(agent) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(agent))
+        throw new Error("Shepherd requires a safe agent name");
+    return new friends_1.FileFriendStore(path.join((0, identity_1.getAgentBundlesRoot)(), `${agent}.ouro`, "friends"));
+}
+function machineShepherdHost(agent) {
+    const root = path.join((0, identity_1.getAgentBundlesRoot)(), `${agent}.ouro`);
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(agent) || !(0, tools_shepherd_1.shepherdToolsEnabled)(root)) {
+        throw new Error("agent does not have Shepherd enabled");
+    }
+    const machine = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(agent);
+    if (!machine.ok)
+        throw new Error("machine Shepherd connection configuration is unavailable");
+    const connection = (0, shepherd_config_1.resolveShepherdConnection)(agent, machine.config);
+    if (!connection.ok)
+        throw new Error(connection.error);
+    if (connection.connection.host !== "cmux")
+        throw new Error("the dedicated composer requires cmux stable surface UUIDs");
+    return (0, host_1.createShepherdHost)(connection.connection, { agentName: agent });
+}
+async function listShepherdTargets(host, composerTty) {
+    return (await host.list()).filter(session => session.agent && exports.SHEPHERD_UUID.test(session.id)
+        && (!composerTty || (session.tty && session.tty.replace(/^\/dev\//, "") !== composerTty.replace(/^\/dev\//, "")))).map(session => Object.freeze({
+        id: session.id,
+        host: "cmux",
+        label: [session.agent, session.cwd, session.workspaceTitle, session.title]
+            .filter(Boolean).map(part => part.replace(/[\x00-\x1f\x7f-\x9f]/g, "").slice(0, 160)).join(" / "),
+    }));
+}
+async function validateShepherdTarget(host, id) {
+    if (!exports.SHEPHERD_UUID.test(id))
+        throw new Error("Shepherd session must be a stable UUID");
+    const matches = (await listShepherdTargets(host)).filter(target => target.id.toLowerCase() === id.toLowerCase());
+    if (matches.length !== 1)
+        throw new Error(`selected Shepherd terminal is unavailable: ${id}`);
+    return matches[0];
+}
+async function authorizedShepherdTargets(agent, friendId, composerTty) {
+    const owner = await resolveExistingLocalOwner(localShepherdFriendStore(agent));
+    if (owner !== friendId)
+        throw new Error("Shepherd composer requires this OS user's existing local-family identity");
+    const targets = await listShepherdTargets(machineShepherdHost(agent), composerTty);
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_targets_resolved", message: "resolved authorized independent composer targets", meta: { agent, count: targets.length } });
+    return targets;
+}

package/dist/senses/shepherd/target-binding.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertBoundShepherdTarget = assertBoundShepherdTarget;
+const runtime_1 = require("../../nerves/runtime");
+/** A composer locator is enforced at execution, not merely suggested to the model. */
+function assertBoundShepherdTarget(bound, session, host) {
+    if (!bound)
+        return;
+    if (session !== bound.id || (host !== undefined && host !== bound.host)) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_target_refused", message: "refused a terminal operation outside the fixed composer target", meta: { host: bound.host, session: bound.id } });
+        throw new Error(`this composer is bound to ${bound.host} UUID ${bound.id}; short refs and other targets are refused`);
+    }
+}

package/dist/senses/shepherd/terminal-process.js

@@ -43,13 +43,14 @@ async function runCommand(command, args) {
     const { stdout } = await exec(command, args, { timeout: 3_000, maxBuffer: 4 * 1024 * 1024 });
     return stdout;
 }
-/** One process snapshot and one cwd lookup for all terminals, not a subprocess per polling surface. */
+/** Batched process/cwd lookups; Node launchers need one additional argv snapshot, never a subprocess per surface. */
 async function identifyTerminalProcesses(ttys, run = runCommand) {
     const result = new Map();
     if (ttys.length === 0)
         return result;
     const wanted = new Set(ttys.map((tty) => tty.replace(/^\/dev\//, "")));
     const agents = new Map();
+    const nodeLaunchers = new Map();
     try {
         for (const line of (await run("ps", ["-axo", "pid=,ppid=,pgid=,tpgid=,tty=,comm="])).split("\n")) {
             const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\d+)\s+(-?\d+)\s+(\S+)\s+(.+)$/);
@@ -59,6 +60,8 @@ async function identifyTerminalProcesses(ttys, run = runCommand) {
             if (!wanted.has(tty) || group !== foreground)
                 continue;
             const executable = path.basename(command);
+            if (executable === "node")
+                nodeLaunchers.set(Number(pid), { parent: Number(parent), tty: tty });
             const agent = executable === "claude" ? "Claude Code" : executable === "copilot" ? "Copilot" : executable === "codex" ? "Codex" : null;
             if (!agent)
                 continue;
@@ -71,6 +74,24 @@ async function identifyTerminalProcesses(ttys, run = runCommand) {
         (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_process_lookup_error", message: "could not identify terminal foreground agents", meta: { error: String(error) } });
         return result;
     }
+    if (nodeLaunchers.size > 0) {
+        try {
+            for (const line of (await run("ps", ["-p", [...nodeLaunchers.keys()].join(","), "-o", "pid=,args="])).split("\n")) {
+                const match = line.trim().match(/^(\d+)\s+\S+\s+(\S+)/);
+                if (!match)
+                    continue;
+                const launcher = nodeLaunchers.get(Number(match[1]));
+                if (!launcher || !/(?:^|\/)copilot\/pkg\/[^/]+\/[^/]+\/cli-main\.js$/.test(match[2]))
+                    continue;
+                const candidates = agents.get(launcher.tty) ?? [];
+                candidates.push({ pid: Number(match[1]), parent: launcher.parent, agent: "Copilot" });
+                agents.set(launcher.tty, candidates);
+            }
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_process_lookup_error", message: "could not identify Node-hosted terminal agents", meta: { error: String(error) } });
+        }
+    }
     const selected = new Map();
     for (const [tty, candidates] of agents) {
         const outer = candidates.find((candidate) => !candidates.some((parent) => parent.pid === candidate.parent));

package/dist/senses/teams.js

@@ -1278,6 +1278,8 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
         });
         return { delivered: false, reason: "internal_content_blocked" };
     }
+    let conversationId;
+    let activityAttempted = false;
     try {
         const conversation = await conversations.create({
             bot: { id: deps.botApi.id },
@@ -1285,7 +1287,9 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
             tenantId: aadInfo.tenantId,
             isGroup: false,
         });
-        await conversations.activities(conversation.id).create({
+        conversationId = conversation.id;
+        activityAttempted = true;
+        const activity = await conversations.activities(conversation.id).create({
             type: "message",
             text: params.text,
             ...(params.textFormat ? { textFormat: params.textFormat } : {}),
@@ -1296,7 +1300,11 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
             message: "proactive teams message sent",
             meta: { friendId: params.friendId, aadObjectId: aadInfo.aadObjectId, sessionKey: params.sessionKey },
         });
-        return { delivered: true };
+        const messageId = activity && typeof activity === "object" && "id" in activity && typeof activity.id === "string" ? activity.id : undefined;
+        return {
+            delivered: true,
+            ...(params.captureReceipt ? { delivery: { state: "accepted", conversationId, ...(messageId ? { messageId } : {}) } } : {}),
+        };
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -1311,7 +1319,19 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
                 reason: error instanceof Error ? error.message : String(error),
             },
         });
-        return { delivered: false, reason: "send_error" };
+        let status;
+        if (error && typeof error === "object") {
+            if ("statusCode" in error)
+                status = error.statusCode;
+            else if ("status" in error)
+                status = error.status;
+        }
+        const rejected = typeof status === "number" && status >= 400 && status < 500 && status !== 408 && status !== 409;
+        const state = !activityAttempted || rejected ? "not_sent" : "unknown";
+        return {
+            delivered: false, reason: "send_error",
+            ...(params.captureReceipt ? { delivery: { state, ...(conversationId ? { conversationId } : {}) } } : {}),
+        };
     }
 }
 function scanPendingTeamsFiles(pendingRoot) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.922",
+  "version": "0.1.0-alpha.924",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.922",
+      "version": "0.1.0-alpha.924",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.922",
+  "version": "0.1.0-alpha.924",
   "engines": {
     "node": ">=22"
   },