@canonmsg/core 0.7.0 → 0.7.2

package/dist/browser.d.ts

@@ -1,5 +1,9 @@
 export { AGENT_CAPABILITIES, } from './types.js';
+export { resolveCanonBaseUrl } from './base-url.js';
+export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL, DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from './constants.js';
 export type { AgentCapabilities, AgentClientType, AgentRuntime, MediaAttachment, MediaAttachmentKind, ModelOption, SessionConfig, WorkspaceOption, } from './types.js';
+export { EXECUTION_ENVIRONMENT_MODES, isExecutionEnvironmentMode, } from './execution-environment-mode.js';
+export type { ExecutionEnvironmentMode } from './execution-environment-mode.js';
 export type { CanonResolvedWorkSession, CanonWorkSession, CanonWorkSessionContext, CanonWorkSessionConversationRole, CanonWorkSessionDisclosureMode, CanonWorkSessionParticipant, CanonWorkSessionStatus, CreateWorkSessionOptions, SendLinkedMessageOptions, SendLinkedMessageResult, UpdateWorkSessionConversationOptions, WorkSessionPromptRenderOptions, } from './work-session.js';
 export { buildWorkSessionPromptLines, buildWorkSessionsPromptLines, mergeWorkSessionContexts, } from './work-session.js';
 export type { AgentBehaviorSettings, ParticipationHistoryMessage, ParticipationHistorySnapshot, ParticipationStyle, ResolvedAgentBehaviorPolicy, } from './policy.js';

package/dist/browser.js

@@ -1,4 +1,7 @@
 export { AGENT_CAPABILITIES, } from './types.js';
+export { resolveCanonBaseUrl } from './base-url.js';
+export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL, DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from './constants.js';
+export { EXECUTION_ENVIRONMENT_MODES, isExecutionEnvironmentMode, } from './execution-environment-mode.js';
 export { buildWorkSessionPromptLines, buildWorkSessionsPromptLines, mergeWorkSessionContexts, } from './work-session.js';
 export { buildParticipationHistorySnapshot, buildParticipationHistorySnapshots, buildBehaviorPolicyLines, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, evaluateParticipationPolicy, getDefaultParticipationPolicy, resolveAgentBehaviorPolicy, } from './policy.js';
 export { DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, isTurnOpen, normalizeTurnMetadata, normalizeTurnState, resolveTurnMessageSemantics, shouldPromoteConversationMessage, shouldTriggerAgentTurn, } from './turn-protocol.js';

package/dist/execution-environment-mode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Browser-safe helpers for Canon execution modes. Separated from
+ * `execution-environment.ts` (which pulls in Node-only modules) so both
+ * Node hosts and browser/Expo clients can import these primitives.
+ */
+export type ExecutionEnvironmentMode = 'worktree' | 'locked';
+export declare const EXECUTION_ENVIRONMENT_MODES: readonly ExecutionEnvironmentMode[];
+export declare function isExecutionEnvironmentMode(value: unknown): value is ExecutionEnvironmentMode;

package/dist/execution-environment-mode.js

@@ -0,0 +1,12 @@
+/**
+ * Browser-safe helpers for Canon execution modes. Separated from
+ * `execution-environment.ts` (which pulls in Node-only modules) so both
+ * Node hosts and browser/Expo clients can import these primitives.
+ */
+export const EXECUTION_ENVIRONMENT_MODES = [
+    'worktree',
+    'locked',
+];
+export function isExecutionEnvironmentMode(value) {
+    return value === 'worktree' || value === 'locked';
+}

package/dist/execution-environment.d.ts

@@ -1,5 +1,7 @@
 import type { WorkspaceOption } from './types.js';
-export type ExecutionEnvironmentMode = 'worktree' | 'locked';
+import { EXECUTION_ENVIRONMENT_MODES, isExecutionEnvironmentMode, type ExecutionEnvironmentMode } from './execution-environment-mode.js';
+export { EXECUTION_ENVIRONMENT_MODES, isExecutionEnvironmentMode };
+export type { ExecutionEnvironmentMode };
 export interface PreparedExecutionEnvironment {
     cwd: string;
     baseCwd: string;
@@ -24,6 +26,7 @@ export interface ConfiguredWorkspaceOption extends WorkspaceResolverOption {
 export interface SessionWorkspaceConfig {
     workspaceId?: string;
     model?: string;
+    executionMode?: ExecutionEnvironmentMode;
     retiredWorkspaceConfig?: boolean;
 }
 export declare function normalizeOptionalString(value: unknown): string | undefined;
@@ -56,4 +59,3 @@ export declare function prepareConversationEnvironment(input: {
     allowWorktrees?: boolean;
 }): PreparedExecutionEnvironment;
 export declare function releaseConversationEnvironment(environment: Pick<PreparedExecutionEnvironment, 'lockPath'>): void;
-export {};

package/dist/execution-environment.js

@@ -1,8 +1,10 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
-import { CANON_DIR, isProcessAlive } from './agent-profiles.js';
+import { CANON_DIR } from './agent-profiles.js';
+import { EXECUTION_ENVIRONMENT_MODES, isExecutionEnvironmentMode, } from './execution-environment-mode.js';
+export { EXECUTION_ENVIRONMENT_MODES, isExecutionEnvironmentMode };
 export class ExecutionEnvironmentError extends Error {
     userMessage;
     constructor(message, userMessage = message) {
@@ -54,46 +56,19 @@ function detectRepoRoot(cwd) {
     const repoRoot = result.stdout.trim();
     return repoRoot ? resolve(repoRoot) : null;
 }
-function isRepoClean(repoRoot) {
-    const result = runGit(repoRoot, ['status', '--porcelain']);
-    return result.ok && result.stdout.trim() === '';
-}
 function branchExists(repoRoot, branch) {
     return runGit(repoRoot, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]).ok;
 }
-function loadWorkspaceLock(lockPath) {
-    try {
-        return JSON.parse(readFileSync(lockPath, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-function cleanupStaleWorkspaceLock(lockPath) {
-    const record = loadWorkspaceLock(lockPath);
-    if (!record) {
-        try {
-            unlinkSync(lockPath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    if (isProcessAlive(record.pid))
-        return false;
-    try {
-        unlinkSync(lockPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function acquireWorkspaceLock(input) {
+// Advisory workspace-usage record. Multiple sessions may share a workspace;
+// we write per-session files (not per-workspace) so nothing contends. Treat
+// these as observability breadcrumbs, not exclusive locks — the name stays
+// for backward compat with existing tooling / docs.
+function recordWorkspaceUsage(input) {
     mkdirSync(WORKSPACE_LOCKS_ROOT, { recursive: true });
     const workspaceCwd = resolve(input.workspaceCwd);
-    const lockPath = join(WORKSPACE_LOCKS_ROOT, `${shortHash(workspaceCwd)}.json`);
+    const workspaceHash = shortHash(workspaceCwd);
+    const sessionHash = shortHash(`${input.agentId}:${input.conversationId}`).slice(0, 8);
+    const lockPath = join(WORKSPACE_LOCKS_ROOT, `${workspaceHash}.${sessionHash}.json`);
     const record = {
         pid: process.pid,
         agentId: input.agentId,
@@ -101,34 +76,13 @@ function acquireWorkspaceLock(input) {
         workspaceCwd,
         createdAt: new Date().toISOString(),
     };
-    while (true) {
-        try {
-            writeFileSync(lockPath, JSON.stringify(record, null, 2), { flag: 'wx' });
-            return lockPath;
-        }
-        catch (error) {
-            const code = error.code;
-            if (code !== 'EEXIST') {
-                throw error;
-            }
-            const existing = loadWorkspaceLock(lockPath);
-            if (!existing) {
-                if (cleanupStaleWorkspaceLock(lockPath))
-                    continue;
-                throw new Error(`Workspace lock file is unreadable: ${workspaceCwd}`);
-            }
-            if (!isProcessAlive(existing.pid)) {
-                if (cleanupStaleWorkspaceLock(lockPath))
-                    continue;
-            }
-            if (existing.pid === process.pid
-                && existing.agentId === input.agentId
-                && existing.conversationId === input.conversationId) {
-                return lockPath;
-            }
-            throw new ExecutionEnvironmentError(`Workspace is already in use by Canon session ${existing.conversationId.slice(0, 8)} (PID ${existing.pid}).`, 'That workspace is already in use by another Canon coding session on this machine.');
-        }
+    try {
+        writeFileSync(lockPath, JSON.stringify(record, null, 2));
     }
+    catch {
+        // Best-effort; an unwritable breadcrumb must not block a session.
+    }
+    return lockPath;
 }
 export function buildConversationEnvironmentKey(conversationId, workspaceCwd) {
     return `${conversationId}:${resolve(workspaceCwd)}`;
@@ -168,9 +122,14 @@ export function readSessionWorkspaceConfig(raw) {
         : undefined;
     const hasRetiredWorkspaceReference = (normalizeOptionalString(data.cwd) !== undefined
         || isRetiredWorkspaceId(rawWorkspaceId));
+    const rawExecutionMode = data.executionMode;
+    const executionMode = isExecutionEnvironmentMode(rawExecutionMode)
+        ? rawExecutionMode
+        : undefined;
     return {
         workspaceId: stableWorkspaceId,
         model: normalizeOptionalString(data.model),
+        ...(executionMode ? { executionMode } : {}),
         ...(!stableWorkspaceId && hasRetiredWorkspaceReference
             ? { retiredWorkspaceConfig: true }
             : {}),
@@ -210,12 +169,12 @@ export function prepareConversationEnvironment(input) {
             cwd: baseCwd,
             baseCwd,
             mode: 'locked',
-            lockPath: acquireWorkspaceLock({
+            lockPath: recordWorkspaceUsage({
                 agentId: input.agentId,
                 conversationId: input.conversationId,
                 workspaceCwd: baseCwd,
             }),
-            reason: 'Worktree isolation is disabled for this host',
+            reason: 'Sharing the base workspace (locked mode)',
         };
     }
     const repoRoot = detectRepoRoot(baseCwd);
@@ -235,7 +194,11 @@ export function prepareConversationEnvironment(input) {
                 };
             }
         }
-        else if (isRepoClean(repoRoot)) {
+        else {
+            // `git worktree add` works fine even when the source worktree is dirty —
+            // uncommitted changes stay with the source tree, the new worktree is
+            // based on HEAD. Historically we required a clean repo and silently fell
+            // through to locked mode; that failure mode surprised users. Just try.
             mkdirSync(dirname(spec.worktreePath), { recursive: true });
             const addArgs = branchExists(repoRoot, spec.branch)
                 ? ['worktree', 'add', spec.worktreePath, spec.branch]
@@ -257,14 +220,14 @@ export function prepareConversationEnvironment(input) {
         cwd: baseCwd,
         baseCwd,
         mode: 'locked',
-        lockPath: acquireWorkspaceLock({
+        lockPath: recordWorkspaceUsage({
             agentId: input.agentId,
             conversationId: input.conversationId,
             workspaceCwd: baseCwd,
         }),
         reason: repoRoot
-            ? 'Base repository is dirty or worktree creation failed'
-            : 'Workspace is not a git repository',
+            ? 'Worktree creation failed; sharing the base workspace'
+            : 'Workspace is not a git repository; sharing the base workspace',
     };
 }
 export function releaseConversationEnvironment(environment) {

package/dist/index.d.ts

@@ -20,7 +20,7 @@ export { loadProfiles, isProfileLocked, acquireLock, releaseLock, isProcessAlive
 export type { AgentProfile } from './agent-profiles.js';
 export { resolveCanonAgent, resolveCanonProfile, getActiveProfile } from './agent-resolver.js';
 export type { ResolvedAgent } from './agent-resolver.js';
-export { buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildConversationWorktreeSpec, buildPublicWorkspaceOptions, buildWorkspaceOptionId, isEnabledFlag, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, ExecutionEnvironmentError, prepareConversationEnvironment, releaseConversationEnvironment, } from './execution-environment.js';
+export { buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildConversationWorktreeSpec, buildPublicWorkspaceOptions, buildWorkspaceOptionId, EXECUTION_ENVIRONMENT_MODES, isEnabledFlag, isExecutionEnvironmentMode, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, ExecutionEnvironmentError, prepareConversationEnvironment, releaseConversationEnvironment, } from './execution-environment.js';
 export type { ConfiguredWorkspaceOption, ExecutionEnvironmentMode, PreparedExecutionEnvironment, SessionWorkspaceConfig, } from './execution-environment.js';
 export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState, writeTurnState, clearTurnState, } from './rtdb-rest.js';
 export type { SessionStatePayload, TurnStatePayload } from './rtdb-rest.js';

package/dist/index.js

@@ -21,7 +21,7 @@ export { loadProfiles, isProfileLocked, acquireLock, releaseLock, isProcessAlive
 // Agent resolver
 export { resolveCanonAgent, resolveCanonProfile, getActiveProfile } from './agent-resolver.js';
 // Execution environments for host-mode coding sessions
-export { buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildConversationWorktreeSpec, buildPublicWorkspaceOptions, buildWorkspaceOptionId, isEnabledFlag, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, ExecutionEnvironmentError, prepareConversationEnvironment, releaseConversationEnvironment, } from './execution-environment.js';
+export { buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildConversationWorktreeSpec, buildPublicWorkspaceOptions, buildWorkspaceOptionId, EXECUTION_ENVIRONMENT_MODES, isEnabledFlag, isExecutionEnvironmentMode, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, ExecutionEnvironmentError, prepareConversationEnvironment, releaseConversationEnvironment, } from './execution-environment.js';
 // RTDB REST helpers (token exchange, session state, generic read/write)
 export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState, writeTurnState, clearTurnState, } from './rtdb-rest.js';
 // Constants

package/dist/types.d.ts

@@ -1,5 +1,7 @@
+import type { ExecutionEnvironmentMode } from './execution-environment-mode.js';
 import type { ResolvedAgentBehaviorPolicy } from './policy.js';
 import type { CanonWorkSessionContext } from './work-session.js';
+export type { ExecutionEnvironmentMode };
 export type MediaAttachmentKind = 'image' | 'audio' | 'file';
 export interface MediaAttachment {
     kind: MediaAttachmentKind;
@@ -11,6 +13,10 @@ export interface MediaAttachment {
     height?: number;
     durationMs?: number;
 }
+export interface ForwardedFrom {
+    sourceConversationId: string;
+    messageId: string;
+}
 export interface CanonMessage {
     id: string;
     senderId: string;
@@ -19,13 +25,12 @@ export interface CanonMessage {
     isOwner: boolean;
     contentType: 'text' | 'image' | 'audio' | 'file' | 'contact_card';
     text: string | null;
-    imageUrl: string | null;
-    audioUrl: string | null;
-    audioDurationMs: number | null;
-    attachments?: MediaAttachment[];
+    attachments: MediaAttachment[];
     mentions: string[];
     replyTo: string | null;
     replyToPosition: number | null;
+    forwarded?: boolean;
+    forwardedFrom?: ForwardedFrom;
     workSession?: CanonWorkSessionContext | null;
     metadata?: Record<string, unknown>;
     status: 'sent' | 'read';
@@ -59,6 +64,12 @@ export type AgentClientType = 'claude-code' | 'openclaw' | 'codex' | 'generic';
 export interface AgentCapabilities {
     supportsModelSwitch: boolean;
     supportsPermissionMode: boolean;
+    /**
+     * Whether permissionMode can be changed mid-session. When undefined,
+     * defaults to `supportsPermissionMode` — keep the UI chip non-interactive
+     * for agents whose approval mode is locked at session creation.
+     */
+    supportsRuntimePermissionMode?: boolean;
     supportsEffort: boolean;
     supportsSessionState: boolean;
     supportsInterrupt: boolean;
@@ -101,12 +112,11 @@ export interface MessageCreatedPayload {
         isOwner?: boolean;
         text?: string;
         contentType?: 'text' | 'image' | 'audio' | 'file' | 'contact_card';
-        imageUrl?: string;
-        audioUrl?: string;
-        audioDurationMs?: number;
         attachments?: MediaAttachment[];
         replyTo?: string;
         replyToPosition?: number;
+        forwarded?: boolean;
+        forwardedFrom?: ForwardedFrom;
         mentions?: string[];
         createdAt?: string;
         workSession?: CanonWorkSessionContext | null;
@@ -128,9 +138,6 @@ export interface SendMessageOptions {
     contentType?: 'text' | 'audio' | 'image' | 'file' | 'contact_card';
     replyTo?: string;
     replyToPosition?: number;
-    audioUrl?: string;
-    audioDurationMs?: number;
-    imageUrl?: string;
     attachments?: MediaAttachment[];
     contactCardUserId?: string;
     mentions?: string[];
@@ -186,16 +193,39 @@ export interface SessionConfig {
     model?: string;
     permissionMode?: string;
     workspaceId?: string;
+    /**
+     * Explicitly selected execution mode. Sessions created before this field
+     * existed stay `undefined`; UIs must prompt for a value and plugin hosts
+     * fail-closed rather than inferring one.
+     */
+    executionMode?: ExecutionEnvironmentMode;
     availableModels?: ModelOption[];
     workspaceOptions?: WorkspaceOption[];
+    availableExecutionModes?: ExecutionEnvironmentMode[];
     updatedAt?: number;
 }
+export interface PermissionModeOption {
+    value: string;
+    label: string;
+}
 export interface AgentRuntime {
     clientType?: AgentClientType;
     hostMode?: boolean;
     defaultModel?: string;
     defaultPermissionMode?: string;
+    availablePermissionModes?: PermissionModeOption[];
     defaultWorkspaceId?: string;
+    /**
+     * Execution modes the host will accept. The runtime advertises this so the
+     * app can offer matching choices; it is NOT used to auto-populate missing
+     * session-config values.
+     */
+    availableExecutionModes?: ExecutionEnvironmentMode[];
+    /**
+     * Reference default surfaced to UI. Treated as advisory only — callers must
+     * still have the user confirm a selection before persisting.
+     */
+    defaultExecutionMode?: ExecutionEnvironmentMode;
     availableModels?: ModelOption[];
     availableWorkspaces?: WorkspaceOption[];
     updatedAt?: number;

package/dist/types.js

@@ -12,6 +12,7 @@ export const AGENT_CAPABILITIES = {
     'claude-code': {
         supportsModelSwitch: true,
         supportsPermissionMode: true,
+        supportsRuntimePermissionMode: true,
         supportsEffort: true,
         supportsSessionState: true,
         supportsInterrupt: true,
@@ -20,7 +21,8 @@ export const AGENT_CAPABILITIES = {
     },
     'codex': {
         supportsModelSwitch: false,
-        supportsPermissionMode: false,
+        supportsPermissionMode: true,
+        supportsRuntimePermissionMode: false,
         supportsEffort: false,
         supportsSessionState: true,
         supportsInterrupt: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/core",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Canon core — shared types, REST client, SSE stream, and registration for Canon messaging",
   "type": "module",
   "main": "dist/index.js",