spawnfile 0.1.2 → 0.1.4

package/dist/compiler/view/renderTree.js

@@ -0,0 +1,59 @@
+import { formatSourceMeta } from "./sourcePaths.js";
+const color = (value, code, options) => options.color ? `\u001b[${code}m${value}\u001b[0m` : value;
+const formatNode = (node, options, projectRoot) => {
+    const kind = color(node.kind, node.kind === "team" ? "36" : "32", options);
+    const metadata = node.kind === "team"
+        ? [
+            node.mode ? `mode=${node.mode}` : undefined,
+            node.lead ? `lead=${node.lead}` : undefined,
+            node.external && node.external.length > 0
+                ? `external=${node.external.join(",")}`
+                : undefined
+        ]
+        : [
+            node.runtimeName ? `[${node.runtimeName}]` : undefined,
+            node.runtimeName ? `runtime=${node.runtimeName}` : undefined
+        ];
+    const details = metadata.filter((entry) => entry !== undefined);
+    const source = options.paths ? formatSourceMeta("source", node.source, projectRoot) : "";
+    const separator = details[0]?.startsWith("[") ? " " : "  ";
+    return `${kind} ${node.displayName}${details.length > 0 ? `${separator}${details.join(" ")}` : ""}${source}`;
+};
+const formatEdgeLabel = (edge) => edge.relation === "subagent"
+    ? `subagent ${edge.label}`
+    : edge.label;
+const formatNetworkSummary = (network, options) => {
+    const id = color(network.id, "36", options);
+    const exposed = network.expose ? " exposed" : "";
+    const rooms = network.rooms
+        .map((room) => `${room.id} [${room.declaredMembers.join(", ")}]`)
+        .join("; ");
+    return `network ${id} "${network.name}"${exposed}: ${rooms}`;
+};
+const renderChildren = (node, options, projectRoot, prefix = "") => {
+    const glyphs = options.ascii
+        ? { branch: "|-- ", last: "`-- ", pipe: "|   ", space: "    " }
+        : { branch: "├── ", last: "└── ", pipe: "│   ", space: "    " };
+    const items = [
+        ...(node.networks ?? []).map((network) => ({ kind: "network", network })),
+        ...node.children.map((edge) => ({ kind: "edge", edge }))
+    ];
+    return items.flatMap((item, index) => {
+        const isLast = index === items.length - 1;
+        const connector = isLast ? glyphs.last : glyphs.branch;
+        const nextPrefix = `${prefix}${isLast ? glyphs.space : glyphs.pipe}`;
+        if (item.kind === "network") {
+            return [`${prefix}${connector}${formatNetworkSummary(item.network, options)}`];
+        }
+        const edge = item.edge;
+        const line = `${prefix}${connector}${formatEdgeLabel(edge)}: ${formatNode(edge.node, options, projectRoot)}`;
+        return [
+            line,
+            ...renderChildren(edge.node, options, projectRoot, nextPrefix)
+        ];
+    });
+};
+export const renderOrganizationTree = (view, options = {}) => [
+    formatNode(view.root, options, view.projectRoot),
+    ...renderChildren(view.root, options, view.projectRoot)
+].join("\n");

package/dist/compiler/view/sourcePaths.d.ts

@@ -0,0 +1,2 @@
+export declare const formatSourcePath: (sourcePath: string, projectRoot: string | undefined) => string;
+export declare const formatSourceMeta: (label: string, sourcePath: string, projectRoot: string | undefined) => string;

package/dist/compiler/view/sourcePaths.js

@@ -0,0 +1,19 @@
+import path from "node:path";
+export const formatSourcePath = (sourcePath, projectRoot) => {
+    if (!projectRoot || !path.isAbsolute(sourcePath) || !path.isAbsolute(projectRoot)) {
+        return sourcePath;
+    }
+    const relativePath = path.relative(projectRoot, sourcePath);
+    if (relativePath === ""
+        || relativePath.startsWith("..")
+        || path.isAbsolute(relativePath)) {
+        return sourcePath;
+    }
+    return relativePath.split(path.sep).join("/");
+};
+export const formatSourceMeta = (label, sourcePath, projectRoot) => {
+    const formattedPath = formatSourcePath(sourcePath, projectRoot);
+    return projectRoot
+        ? ` ${label}=${formattedPath}`
+        : ` <${formattedPath}>`;
+};

package/dist/compiler/view/types.d.ts

@@ -0,0 +1,80 @@
+import type { ResolvedMoltnetRoomPolicy } from "../types.js";
+export interface OrganizationViewTreeNode {
+    children: OrganizationViewTreeEdge[];
+    displayName: string;
+    external?: string[];
+    id: string;
+    kind: "agent" | "team";
+    lead?: string | null;
+    mode?: "hierarchical" | "swarm";
+    name: string;
+    networks?: OrganizationTreeNetworkSummary[];
+    runtimeName: string | null;
+    source: string;
+}
+export interface OrganizationTreeNetworkRoomSummary {
+    declaredMembers: string[];
+    id: string;
+}
+export interface OrganizationTreeNetworkSummary {
+    expose: boolean;
+    id: string;
+    name: string;
+    provider: "moltnet";
+    rooms: OrganizationTreeNetworkRoomSummary[];
+}
+export interface OrganizationViewTreeEdge {
+    label: string;
+    node: OrganizationViewTreeNode;
+    relation: "subagent" | "team_member";
+}
+export interface OrganizationNetworkMemberView {
+    agentName: string;
+    agentSource: string;
+    concreteMemberId: string;
+    declaredSlot: string;
+    directTeamName: string;
+    directTeamSource: string;
+    policy?: ResolvedMoltnetRoomPolicy;
+    representedSlot?: string;
+    representedTeamName?: string;
+    representedTeamSource?: string;
+    representativePath?: string[];
+}
+export interface OrganizationNetworkDeclarationView {
+    declaringTeamName: string;
+    declaringTeamSource: string;
+    expose: boolean;
+    name: string;
+    rooms: OrganizationNetworkRoomView[];
+}
+export interface OrganizationNetworkRoomView {
+    declaredMembers: string[];
+    id: string;
+    members: OrganizationNetworkMemberView[];
+}
+export interface OrganizationNetworkView {
+    declaringTeamName: string;
+    declaringTeamSource: string;
+    expose: boolean;
+    id: string;
+    name: string;
+    provider: "moltnet";
+    rooms: OrganizationNetworkRoomView[];
+    declarations?: OrganizationNetworkDeclarationView[];
+}
+export interface OrganizationView {
+    contexts: [];
+    diagnostics: [];
+    inputPath: string;
+    networks: OrganizationNetworkView[];
+    projectRoot?: string;
+    root: OrganizationViewTreeNode;
+    runtimes: [];
+}
+export interface RenderOrganizationViewOptions {
+    ascii?: boolean;
+    color?: boolean;
+    declared?: boolean;
+    paths?: boolean;
+}

package/dist/compiler/view/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/picoclaw/adapter.js

@@ -47,6 +47,13 @@ const buildModelList = (node) => {
                 model_name: target.name
             };
         }
+        if (target.provider === "openai" && target.auth.method === "codex") {
+            return {
+                model: `codex-cli/${target.name}`,
+                model_name: target.name,
+                workspace: "<workspace-path>"
+            };
+        }
         return {
             ...(target.auth.method === "api_key"
                 ? {

package/dist/runtime/picoclaw/runAuth.js

@@ -1,12 +1,12 @@
 import path from "node:path";
-import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../../auth/index.js";
+import { loadImportedClaudeCodeCredential } from "../../auth/index.js";
 import { copyDirectory, ensureDirectory, readUtf8File, writeUtf8File } from "../../filesystem/index.js";
 const resolveRootfsSourcePath = (outputDirectory, containerPath) => path.join(outputDirectory, "container", "rootfs", ...path.posix.relative("/", containerPath).split("/"));
 const createMountArgs = (hostPath, containerPath) => [
     "-v",
     `${hostPath}:${containerPath}`
 ];
-const createMountedHomeDirectory = async (input, patchedConfig, authStore) => {
+const createMountedHomeDirectory = async (input, patchedConfig) => {
     const sourceHomePath = resolveRootfsSourcePath(input.outputDirectory, input.instance.home_path);
     const mountedHomePath = path.join("runtime-auth", "picoclaw", input.instance.id, "home");
     const hostHomePath = path.join(input.tempRoot, mountedHomePath);
@@ -14,26 +14,10 @@ const createMountedHomeDirectory = async (input, patchedConfig, authStore) => {
     await copyDirectory(sourceHomePath, hostHomePath);
     const relativeConfigPath = path.posix.relative(input.instance.home_path, input.instance.config_path);
     const hostConfigPath = path.join(hostHomePath, ...relativeConfigPath.split("/"));
-    const hostAuthPath = path.join(hostHomePath, "auth.json");
     await ensureDirectory(path.dirname(hostConfigPath));
     await writeUtf8File(hostConfigPath, `${JSON.stringify(patchedConfig, null, 2)}\n`);
-    if (authStore) {
-        await writeUtf8File(hostAuthPath, `${JSON.stringify(authStore, null, 2)}\n`);
-    }
     return hostHomePath;
 };
-const createPicoClawCredential = (provider, credential) => ({
-    access_token: credential.access,
-    ...("type" in credential && credential.type === "oauth" && credential.refresh
-        ? { refresh_token: credential.refresh }
-        : !("type" in credential)
-            ? { refresh_token: credential.refresh }
-            : {}),
-    ...("accountId" in credential && credential.accountId ? { account_id: credential.accountId } : {}),
-    auth_method: "oauth",
-    expires_at: new Date(credential.expires).toISOString(),
-    provider
-});
 const normalizeClaudeCliModelName = (modelName) => modelName.replaceAll(".", "-");
 const patchPicoClawConfig = (config, options) => {
     const agents = config.agents ?? {};
@@ -55,21 +39,11 @@ const patchPicoClawConfig = (config, options) => {
                 record.model = `claude-cli/${normalizeClaudeCliModelName(modelName)}`;
             }
         }
-        if (options.useCodex && typeof model === "string" && model.startsWith("openai/")) {
-            delete record.api_key;
-            record.auth_method = "oauth";
-        }
         return record;
     });
     if (options.useClaudeCode) {
         delete nextProviders.anthropic;
     }
-    if (options.useCodex) {
-        nextProviders.openai = {
-            ...(nextProviders.openai ?? {}),
-            auth_method: "oauth"
-        };
-    }
     return {
         ...config,
         agents: {
@@ -87,29 +61,19 @@ export const preparePicoClawRuntimeAuth = async (input) => {
     const claudeCode = input.authProfile.imports["claude-code"]
         ? await loadImportedClaudeCodeCredential(input.authProfile.imports["claude-code"].path)
         : null;
-    const codex = input.authProfile.imports.codex
-        ? await loadImportedCodexCredential(input.authProfile.imports.codex.path)
-        : null;
     const useClaudeCode = input.instance.model_auth_methods.anthropic === "claude-code" && claudeCode;
-    const useCodex = input.instance.model_auth_methods.openai === "codex" && codex;
-    if (!useClaudeCode && !useCodex) {
+    if (!useClaudeCode) {
         return { coveredModelSecrets: [], mountArgs: [] };
     }
-    const credentials = {};
     const coveredModelSecrets = [];
-    if (useCodex) {
-        credentials.openai = createPicoClawCredential("openai", codex);
-        coveredModelSecrets.push("OPENAI_API_KEY");
-    }
     if (useClaudeCode) {
         coveredModelSecrets.push("ANTHROPIC_API_KEY");
     }
     const sourceConfig = JSON.parse(await readUtf8File(resolveRootfsSourcePath(input.outputDirectory, input.instance.config_path)));
     const patchedConfig = patchPicoClawConfig(sourceConfig, {
-        useClaudeCode: Boolean(useClaudeCode),
-        useCodex: Boolean(useCodex)
+        useClaudeCode: Boolean(useClaudeCode)
     });
-    const mountedHomePath = await createMountedHomeDirectory(input, patchedConfig, Object.keys(credentials).length > 0 ? { credentials } : null);
+    const mountedHomePath = await createMountedHomeDirectory(input, patchedConfig);
     return {
         coveredModelSecrets,
         mountArgs: createMountArgs(mountedHomePath, input.instance.home_path)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spawnfile",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Canonical source compiler for autonomous agents and teams.",
   "license": "MIT",
   "type": "module",
@@ -16,7 +16,7 @@
   },
   "scripts": {
     "blueprints": "./scripts/blueprints.sh",
-    "build": "rm -rf dist && tsc --project tsconfig.build.json && node ./scripts/copy-runtime-scaffold-assets.mjs",
+    "build": "rm -rf dist && tsc --project tsconfig.build.json && chmod +x dist/cli/index.js && node ./scripts/copy-runtime-scaffold-assets.mjs",
     "clean": "rm -rf coverage dist",
     "coverage": "vitest run --coverage",
     "dev": "tsx src/cli/index.ts",