@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/create-agent-title.js

@@ -0,0 +1,34 @@
+import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "@bytetrue/byspace-protocol/agent-title-limits";
+const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
+function deriveInitialAgentTitle(prompt) {
+    const firstContentLine = prompt
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstContentLine) {
+        return null;
+    }
+    const normalized = firstContentLine.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return null;
+    }
+    const clamped = normalized.slice(0, MAX_INITIAL_AGENT_TITLE_CHARS).trim();
+    return clamped.length > 0 ? clamped : null;
+}
+export function resolveCreateAgentTitles(options) {
+    const explicitTitle = typeof options.configTitle === "string" && options.configTitle.trim().length > 0
+        ? options.configTitle.trim()
+        : null;
+    const trimmedPrompt = options.initialPrompt?.trim();
+    const provisionalTitle = explicitTitle ?? (trimmedPrompt ? deriveInitialAgentTitle(trimmedPrompt) : null);
+    return {
+        explicitTitle,
+        provisionalTitle,
+    };
+}
+export function resolveFirstAgentPromptTitle(firstAgentContext) {
+    return (resolveCreateAgentTitles({
+        initialPrompt: firstAgentContext?.prompt,
+    }).provisionalTitle ?? null);
+}
+//# sourceMappingURL=create-agent-title.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/dictation-debug.d.ts

@@ -0,0 +1,13 @@
+import type pino from "pino";
+export interface DictationDebugAudioMetadata {
+    sessionId: string;
+    dictationId: string;
+    format: string;
+}
+export interface DictationDebugChunkWriter {
+    folder: string;
+    writeChunk: (seq: number, pcm16: Buffer) => Promise<void>;
+}
+export declare function createDictationDebugChunkWriter(metadata: Pick<DictationDebugAudioMetadata, "sessionId" | "dictationId">, logger: pino.Logger): DictationDebugChunkWriter | null;
+export declare function maybePersistDictationDebugAudio(audio: Buffer, metadata: DictationDebugAudioMetadata, logger: pino.Logger, chunkWriterFolder?: string | null): Promise<string | null>;
+//# sourceMappingURL=dictation-debug.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/dictation-debug.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { inferAudioExtension, sanitizeForFilename } from "./audio-utils.js";
+import { resolveRecordingsDebugDir } from "./recordings-debug.js";
+let announcedDir = null;
+export function createDictationDebugChunkWriter(metadata, logger) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = join(debugDir, sanitizeForFilename(metadata.sessionId, "session"), `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}`);
+    let folderCreated = false;
+    return {
+        folder,
+        writeChunk: async (seq, pcm16) => {
+            if (!folderCreated) {
+                await mkdir(folder, { recursive: true });
+                folderCreated = true;
+            }
+            const paddedSeq = String(seq).padStart(6, "0");
+            const filePath = join(folder, `chunk_${paddedSeq}.pcm`);
+            await writeFile(filePath, pcm16);
+        },
+    };
+}
+export async function maybePersistDictationDebugAudio(audio, metadata, logger, chunkWriterFolder) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = chunkWriterFolder ?? join(debugDir, sanitizeForFilename(metadata.sessionId, "session"));
+    await mkdir(folder, { recursive: true });
+    const filename = chunkWriterFolder
+        ? `combined.${inferAudioExtension(metadata.format)}`
+        : `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}.${inferAudioExtension(metadata.format)}`;
+    const filePath = join(folder, filename);
+    await writeFile(filePath, audio);
+    return filePath;
+}
+//# sourceMappingURL=dictation-debug.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/import-sessions.d.ts

@@ -0,0 +1,47 @@
+import type { z } from "zod";
+import type { Logger } from "pino";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+import type { AgentManager, ManagedAgent } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@bytetrue/byspace-protocol/messages";
+type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
+export interface NormalizedImportAgentRequest {
+    provider: AgentProvider;
+    providerHandleId: string;
+    cwd?: string;
+    labels?: Record<string, string>;
+    requestId: string;
+}
+export declare class ImportSessionsRequestError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface ListImportableProviderSessionsInput {
+    request: FetchRecentProviderSessionsRequestMessage;
+    agentManager: Pick<AgentManager, "listAgents" | "listImportableSessions">;
+    agentStorage: Pick<AgentStorage, "list">;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "getProviderLabel">;
+}
+export interface ListImportableProviderSessionsResult {
+    entries: RecentProviderSessionDescriptorPayload[];
+    filteredAlreadyImportedCount: number;
+}
+export interface ImportProviderSessionInput {
+    request: NormalizedImportAgentRequest;
+    workspaceId: string;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    logger: Logger;
+}
+export interface ImportProviderSessionResult {
+    snapshot: ManagedAgent;
+    timelineSize: number;
+}
+export declare function normalizeImportAgentRequest(msg: ImportAgentRequestMessage): NormalizedImportAgentRequest | {
+    error: string;
+};
+export declare function listImportableProviderSessions(input: ListImportableProviderSessionsInput): Promise<ListImportableProviderSessionsResult>;
+export declare function importProviderSession(input: ImportProviderSessionInput): Promise<ImportProviderSessionResult>;
+export {};
+//# sourceMappingURL=import-sessions.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/import-sessions.js

@@ -0,0 +1,145 @@
+import { unarchiveAgentState } from "./agent-prompt.js";
+import { toRecentProviderSessionDescriptorPayload } from "./agent-projections.js";
+import { createRealpathAwarePathMatcher } from "../../utils/path.js";
+const METADATA_GENERATION_PROMPT_PREFIX = "Generate metadata for a coding agent based on the user prompt.";
+export class ImportSessionsRequestError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ImportSessionsRequestError";
+    }
+}
+// COMPAT(import-agent-request-v1): accept legacy {provider, sessionId} shape
+// alongside the new {providerId, providerHandleId} shape. Old clients
+// (< target daemon floor) send the legacy fields. Drop the fallbacks and the
+// .optional() in messages.ts when the supported client floor is >= the daemon
+// version that ships the new shape (target: 2026-11-08).
+export function normalizeImportAgentRequest(msg) {
+    const provider = msg.providerId ?? msg.provider;
+    const providerHandleId = msg.providerHandleId ?? msg.sessionId;
+    if (!provider || !providerHandleId) {
+        return { error: "Import requires providerId and providerHandleId" };
+    }
+    return {
+        provider: provider,
+        providerHandleId,
+        cwd: msg.cwd,
+        labels: msg.labels,
+        requestId: msg.requestId,
+    };
+}
+export async function listImportableProviderSessions(input) {
+    const { request, agentManager, agentStorage, providerSnapshotManager } = input;
+    const limit = request.limit ?? 20;
+    const sinceTimestamp = parseRecentProviderSessionsSince(request.since);
+    const providerFilter = request.providers ? new Set(request.providers) : undefined;
+    const importedHandles = await collectImportedProviderSessionHandles(agentManager, agentStorage);
+    const sessions = await agentManager.listImportableSessions({
+        limit,
+        providerFilter,
+        cwd: request.cwd,
+    });
+    let filteredAlreadyImportedCount = 0;
+    const candidates = [];
+    const matchesRequestCwd = request.cwd ? createRealpathAwarePathMatcher(request.cwd) : null;
+    for (const session of sessions) {
+        if (matchesRequestCwd && !matchesRequestCwd(session.cwd)) {
+            continue;
+        }
+        if (sinceTimestamp !== null && session.lastActivityAt.getTime() < sinceTimestamp) {
+            continue;
+        }
+        if (isMetadataGenerationSession(session)) {
+            continue;
+        }
+        if (importedHandles.has(toProviderSessionHandleKey(session.provider, session.providerHandleId))) {
+            filteredAlreadyImportedCount += 1;
+            continue;
+        }
+        candidates.push(session);
+    }
+    const entries = candidates
+        .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+        .slice(0, limit)
+        .map((descriptor) => toRecentProviderSessionDescriptorPayload(descriptor, {
+        providerLabel: providerSnapshotManager.getProviderLabel(descriptor.provider),
+    }));
+    return { entries, filteredAlreadyImportedCount };
+}
+export async function importProviderSession(input) {
+    const { provider, providerHandleId, cwd, labels } = input.request;
+    if (!cwd) {
+        throw new Error("Import requires cwd from the selected provider session");
+    }
+    const handle = buildImportPersistenceHandle({ provider, providerHandleId, cwd });
+    await unarchiveAgentByHandle(input.agentStorage, input.agentManager, handle);
+    const snapshot = await input.agentManager.importProviderSession({
+        provider,
+        providerHandleId,
+        cwd,
+        workspaceId: input.workspaceId,
+        labels,
+    });
+    await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
+    return {
+        snapshot,
+        timelineSize: input.agentManager.getTimeline(snapshot.id).length,
+    };
+}
+async function unarchiveAgentByHandle(agentStorage, agentManager, handle) {
+    const records = await agentStorage.list();
+    const matched = records.find((record) => record.persistence?.provider === handle.provider &&
+        (record.persistence.sessionId === handle.sessionId ||
+            record.persistence.nativeHandle === handle.nativeHandle));
+    if (!matched) {
+        return;
+    }
+    await unarchiveAgentState(agentStorage, agentManager, matched.id);
+}
+function parseRecentProviderSessionsSince(since) {
+    if (!since) {
+        return null;
+    }
+    const timestamp = Date.parse(since);
+    if (Number.isNaN(timestamp)) {
+        throw new ImportSessionsRequestError("invalid_since", "Invalid recent provider sessions since");
+    }
+    return timestamp;
+}
+function buildImportPersistenceHandle(input) {
+    return {
+        provider: input.provider,
+        sessionId: input.providerHandleId,
+        nativeHandle: input.providerHandleId,
+        metadata: {
+            provider: input.provider,
+            cwd: input.cwd,
+        },
+    };
+}
+async function collectImportedProviderSessionHandles(agentManager, agentStorage) {
+    const handles = new Set();
+    for (const agent of agentManager.listAgents()) {
+        collectProviderSessionHandleKeys(handles, agent.provider, agent.persistence);
+    }
+    for (const record of await agentStorage.list()) {
+        collectProviderSessionHandleKeys(handles, record.provider, record.persistence);
+    }
+    return handles;
+}
+function toProviderSessionHandleKey(provider, providerHandleId) {
+    return `${provider}\0${providerHandleId}`;
+}
+function isMetadataGenerationSession(input) {
+    return (input.firstPromptPreview?.trimStart().startsWith(METADATA_GENERATION_PROMPT_PREFIX) ?? false);
+}
+function collectProviderSessionHandleKeys(target, provider, persistence) {
+    if (!persistence) {
+        return;
+    }
+    target.add(toProviderSessionHandleKey(provider, persistence.sessionId));
+    if (persistence.nativeHandle) {
+        target.add(toProviderSessionHandleKey(provider, persistence.nativeHandle));
+    }
+}
+//# sourceMappingURL=import-sessions.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/lifecycle-command.d.ts

@@ -0,0 +1,73 @@
+import type { Logger } from "pino";
+import { type AgentRunCancellationResult, type ManagedAgent } from "./agent-manager.js";
+import type { StoredAgentRecord } from "./agent-storage.js";
+import type { AgentProviderNotice } from "./agent-sdk-types.js";
+export type LifecycleAgentSnapshot = Pick<ManagedAgent, "id" | "cwd" | "lifecycle">;
+export interface LifecycleAgentManager {
+    getAgent(agentId: string): LifecycleAgentSnapshot | null;
+    hasInFlightRun(agentId: string): boolean;
+    cancelAgentRun(agentId: string): Promise<AgentRunCancellationResult>;
+    clearAgentAttention(agentId: string): Promise<void>;
+    archiveAgent(agentId: string): Promise<{
+        archivedAt: string;
+    }>;
+    archiveSnapshot(agentId: string, archivedAt: string): Promise<StoredAgentRecord>;
+    closeAgent(agentId: string): Promise<void>;
+    setLabels(agentId: string, labels: Record<string, string>): Promise<void>;
+    detachAgent(agentId: string): Promise<{
+        record: StoredAgentRecord;
+        live: boolean;
+        previousParentAgentId: string | null;
+    }>;
+    notifyAgentState(agentId: string): void;
+    setAgentMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
+    updateAgentMetadata(agentId: string, updates: {
+        title?: string;
+        labels?: Record<string, string>;
+    }): Promise<void>;
+}
+export interface LifecycleAgentStorage {
+    get(agentId: string): Promise<StoredAgentRecord | null>;
+    upsert(record: StoredAgentRecord): Promise<void>;
+}
+export interface AgentLifecycleCommandDependencies {
+    agentManager: LifecycleAgentManager;
+    agentStorage: LifecycleAgentStorage;
+    logger: Logger;
+}
+export interface CancelAgentRunResult {
+    agent: LifecycleAgentSnapshot;
+    cancelled: boolean;
+}
+export declare function cancelAgentRunCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager" | "logger">, agentId: string): Promise<CancelAgentRunResult>;
+export interface ArchiveAgentResult {
+    agentId: string;
+    archivedAt: string;
+    record: StoredAgentRecord;
+}
+export declare function archiveAgentCommand(dependencies: AgentLifecycleCommandDependencies, agentId: string): Promise<ArchiveAgentResult>;
+export declare function closeAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, agentId: string): Promise<void>;
+export interface UpdateAgentResult {
+    accepted: boolean;
+    error: string | null;
+}
+export declare function updateAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, input: {
+    agentId: string;
+    name?: string;
+    labels?: Record<string, string>;
+}): Promise<UpdateAgentResult>;
+export interface DetachAgentResult {
+    agentId: string;
+    record: StoredAgentRecord;
+    live: boolean;
+    previousParentAgentId: string | null;
+}
+export declare function detachAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, agentId: string): Promise<DetachAgentResult>;
+export declare function setAgentModeCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, input: {
+    agentId: string;
+    modeId: string;
+}): Promise<{
+    modeId: string;
+    notice: AgentProviderNotice | null;
+}>;
+//# sourceMappingURL=lifecycle-command.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/lifecycle-command.js

@@ -0,0 +1,99 @@
+import { AgentRunCancellationError, } from "./agent-manager.js";
+async function requestAgentRunCancellation(dependencies, agentId) {
+    const { agentManager, logger } = dependencies;
+    const agent = agentManager.getAgent(agentId);
+    if (!agent) {
+        logger.trace({ agentId }, "cancelAgentRunCommand: agent not found");
+        throw new Error(`Agent ${agentId} not found`);
+    }
+    const hasInFlightRun = agentManager.hasInFlightRun(agentId);
+    if (!hasInFlightRun) {
+        logger.trace({ agentId, lifecycle: agent.lifecycle, hasInFlightRun }, "cancelAgentRunCommand: skipping because agent is not running");
+        return { agent, cancelled: false, cancellation: { status: "not_running" } };
+    }
+    logger.debug({ agentId, lifecycle: agent.lifecycle, hasInFlightRun }, "cancelAgentRunCommand: interrupting");
+    const startedAt = Date.now();
+    const cancellation = await agentManager.cancelAgentRun(agentId);
+    logger.debug({ agentId, cancellation: cancellation.status, durationMs: Date.now() - startedAt }, "cancelAgentRunCommand: cancelAgentRun completed");
+    return {
+        agent,
+        cancelled: cancellation.status === "settled",
+        cancellation,
+    };
+}
+export async function cancelAgentRunCommand(dependencies, agentId) {
+    const result = await requestAgentRunCancellation(dependencies, agentId);
+    if (result.cancellation.status === "refused") {
+        dependencies.logger.warn({ agentId }, "cancelAgentRunCommand: reported running but no active run was cancelled");
+        throw new AgentRunCancellationError(agentId, "stop");
+    }
+    return { agent: result.agent, cancelled: result.cancelled };
+}
+export async function archiveAgentCommand(dependencies, agentId) {
+    const liveAgent = dependencies.agentManager.getAgent(agentId);
+    let record;
+    if (liveAgent) {
+        await requestAgentRunCancellation(dependencies, agentId);
+        await dependencies.agentManager.clearAgentAttention(agentId).catch(() => undefined);
+        await dependencies.agentManager.archiveAgent(agentId);
+        record = await dependencies.agentStorage.get(agentId);
+    }
+    else {
+        record = await archiveStoredAgent(dependencies, agentId);
+    }
+    if (!record) {
+        throw new Error(`Agent not found in storage after archive: ${agentId}`);
+    }
+    if (!record.archivedAt) {
+        throw new Error(`Agent missing archivedAt after archive: ${agentId}`);
+    }
+    return {
+        agentId,
+        archivedAt: record.archivedAt,
+        record,
+    };
+}
+export async function closeAgentCommand(dependencies, agentId) {
+    await dependencies.agentManager.closeAgent(agentId);
+}
+export async function updateAgentCommand(dependencies, input) {
+    const title = input.name?.trim();
+    const labels = input.labels && Object.keys(input.labels).length > 0 ? input.labels : undefined;
+    if (!title && !labels) {
+        return {
+            accepted: false,
+            error: "Nothing to update (provide name and/or labels)",
+        };
+    }
+    await dependencies.agentManager.updateAgentMetadata(input.agentId, {
+        ...(title ? { title } : {}),
+        ...(labels ? { labels } : {}),
+    });
+    return {
+        accepted: true,
+        error: null,
+    };
+}
+export async function detachAgentCommand(dependencies, agentId) {
+    const result = await dependencies.agentManager.detachAgent(agentId);
+    return {
+        agentId,
+        ...result,
+    };
+}
+export async function setAgentModeCommand(dependencies, input) {
+    const notice = await dependencies.agentManager.setAgentMode(input.agentId, input.modeId);
+    return { modeId: input.modeId, notice };
+}
+async function archiveStoredAgent(dependencies, agentId) {
+    const existing = await dependencies.agentStorage.get(agentId);
+    if (!existing) {
+        throw new Error(`Agent not found: ${agentId}`);
+    }
+    if (existing.archivedAt) {
+        return existing;
+    }
+    const archivedAt = new Date().toISOString();
+    return dependencies.agentManager.archiveSnapshot(agentId, archivedAt);
+}
+//# sourceMappingURL=lifecycle-command.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/mcp-server.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type BySpaceToolHostDependencies } from "./tools/byspace-tools.js";
+export type AgentMcpServerOptions = BySpaceToolHostDependencies;
+export declare function createAgentMcpServer(options: AgentMcpServerOptions): Promise<McpServer>;
+//# sourceMappingURL=mcp-server.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/mcp-server.js

@@ -0,0 +1,66 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createBySpaceToolCatalog, } from "./tools/byspace-tools.js";
+function formatStructuredContentForModel(structuredContent) {
+    if (!structuredContent ||
+        typeof structuredContent !== "object" ||
+        Array.isArray(structuredContent)) {
+        return JSON.stringify(structuredContent, null, 2);
+    }
+    const record = structuredContent;
+    const summary = [];
+    for (const [key, value] of Object.entries(record)) {
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        summary.push(`${key}_count=${value.length}`);
+        const ids = value
+            .map((item) => item && typeof item === "object" && !Array.isArray(item)
+            ? item.id
+            : null)
+            .filter((id) => typeof id === "string" && id.length > 0);
+        if (ids.length === value.length && ids.length > 0) {
+            summary.push(`${key}_ids=${ids.join(",")}`);
+        }
+    }
+    const json = JSON.stringify(structuredContent, null, 2);
+    return summary.length > 0 ? `${summary.join("\n")}\n\n${json}` : json;
+}
+function addModelVisibleStructuredContent(result) {
+    if (result.structuredContent === undefined || result.content.length > 0) {
+        return result;
+    }
+    return {
+        ...result,
+        content: [
+            {
+                type: "text",
+                text: formatStructuredContentForModel(result.structuredContent),
+            },
+        ],
+    };
+}
+function toMcpToolResult(result) {
+    return addModelVisibleStructuredContent({
+        content: result.content,
+        ...(result.structuredContent !== undefined
+            ? { structuredContent: result.structuredContent }
+            : {}),
+        ...(result.isError !== undefined ? { isError: result.isError } : {}),
+    });
+}
+export async function createAgentMcpServer(options) {
+    const catalog = await createBySpaceToolCatalog(options);
+    const server = new McpServer({
+        name: "agent-mcp",
+        version: "2.0.0",
+    });
+    for (const tool of catalog.tools.values()) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }, async (args, context) => toMcpToolResult(await catalog.executeTool(tool.name, args, { signal: context?.signal })));
+    }
+    return server;
+}
+//# sourceMappingURL=mcp-server.js.map