@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/schedule/rpc-schemas.js

@@ -0,0 +1,155 @@
+import { z } from "zod";
+import { ScheduleCadenceSchema, ScheduleRunSchema, ScheduleSummarySchema, StoredScheduleSchema, ScheduleTargetSchema, } from "./types.js";
+const ScheduleCreateNewAgentConfigSchema = ScheduleTargetSchema.options[1].shape.config;
+const ScheduleCreateTargetSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("self"),
+        agentId: z.guid(),
+    }),
+    z.object({
+        type: z.literal("agent"),
+        agentId: z.guid(),
+    }),
+    z.object({
+        type: z.literal("new-agent"),
+        config: ScheduleCreateNewAgentConfigSchema,
+    }),
+]);
+export const ScheduleCreateRequestSchema = z.object({
+    type: z.literal("schedule/create"),
+    requestId: z.string(),
+    prompt: z.string().min(1),
+    name: z.string().optional(),
+    cadence: ScheduleCadenceSchema,
+    target: ScheduleCreateTargetSchema,
+    maxRuns: z.number().int().positive().optional(),
+    expiresAt: z.string().optional(),
+    runOnCreate: z.boolean().optional(),
+});
+export const ScheduleListRequestSchema = z.object({
+    type: z.literal("schedule/list"),
+    requestId: z.string(),
+});
+export const ScheduleInspectRequestSchema = z.object({
+    type: z.literal("schedule/inspect"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleLogsRequestSchema = z.object({
+    type: z.literal("schedule/logs"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const SchedulePauseRequestSchema = z.object({
+    type: z.literal("schedule/pause"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleResumeRequestSchema = z.object({
+    type: z.literal("schedule/resume"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleDeleteRequestSchema = z.object({
+    type: z.literal("schedule/delete"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleRunOnceRequestSchema = z.object({
+    type: z.literal("schedule/run-once"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+const ScheduleUpdateNewAgentConfigSchema = z.object({
+    provider: z.string().trim().min(1).optional(),
+    model: z.string().trim().min(1).nullable().optional(),
+    modeId: z.string().trim().min(1).nullable().optional(),
+    thinkingOptionId: z.string().trim().min(1).nullable().optional(),
+    archiveOnFinish: z.boolean().optional(),
+    isolation: z.enum(["local", "worktree"]).optional(),
+    cwd: z.string().trim().min(1).optional(),
+});
+export const ScheduleUpdateRequestSchema = z.object({
+    type: z.literal("schedule/update"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+    name: z.string().nullable().optional(),
+    prompt: z.string().min(1).optional(),
+    cadence: ScheduleCadenceSchema.optional(),
+    newAgentConfig: ScheduleUpdateNewAgentConfigSchema.optional(),
+    maxRuns: z.number().int().positive().nullable().optional(),
+    expiresAt: z.string().nullable().optional(),
+});
+export const ScheduleCreateResponseSchema = z.object({
+    type: z.literal("schedule/create/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: ScheduleSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleListResponseSchema = z.object({
+    type: z.literal("schedule/list/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedules: z.array(ScheduleSummarySchema),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleInspectResponseSchema = z.object({
+    type: z.literal("schedule/inspect/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: StoredScheduleSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleLogsResponseSchema = z.object({
+    type: z.literal("schedule/logs/response"),
+    payload: z.object({
+        requestId: z.string(),
+        runs: z.array(ScheduleRunSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const SchedulePauseResponseSchema = z.object({
+    type: z.literal("schedule/pause/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: ScheduleSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleResumeResponseSchema = z.object({
+    type: z.literal("schedule/resume/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: ScheduleSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleDeleteResponseSchema = z.object({
+    type: z.literal("schedule/delete/response"),
+    payload: z.object({
+        requestId: z.string(),
+        scheduleId: z.string(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleRunOnceResponseSchema = z.object({
+    type: z.literal("schedule/run-once/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: StoredScheduleSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleUpdateResponseSchema = z.object({
+    type: z.literal("schedule/update/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: StoredScheduleSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+//# sourceMappingURL=rpc-schemas.js.map

package/dist/schedule/types.d.ts

@@ -0,0 +1,201 @@
+import { z } from "zod";
+export declare const ScheduleStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    active: "active";
+    paused: "paused";
+}>;
+export type ScheduleStatus = z.infer<typeof ScheduleStatusSchema>;
+export declare const ScheduleCadenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"every">;
+    everyMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type ScheduleCadence = z.infer<typeof ScheduleCadenceSchema>;
+export declare const ScheduleTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"agent">;
+    agentId: z.ZodGUID;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"new-agent">;
+    config: z.ZodObject<{
+        provider: z.ZodString;
+        cwd: z.ZodString;
+        modeId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        thinkingOptionId: z.ZodOptional<z.ZodString>;
+        archiveOnFinish: z.ZodOptional<z.ZodBoolean>;
+        isolation: z.ZodOptional<z.ZodEnum<{
+            local: "local";
+            worktree: "worktree";
+        }>>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type ScheduleTarget = z.infer<typeof ScheduleTargetSchema>;
+export declare const ScheduleRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    scheduledFor: z.ZodString;
+    startedAt: z.ZodString;
+    endedAt: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        succeeded: "succeeded";
+    }>;
+    agentId: z.ZodNullable<z.ZodGUID>;
+    workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    output: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ScheduleRun = z.infer<typeof ScheduleRunSchema>;
+export declare const StoredScheduleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    prompt: z.ZodString;
+    cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"every">;
+        everyMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        agentId: z.ZodGUID;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"new-agent">;
+        config: z.ZodObject<{
+            provider: z.ZodString;
+            cwd: z.ZodString;
+            modeId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            thinkingOptionId: z.ZodOptional<z.ZodString>;
+            archiveOnFinish: z.ZodOptional<z.ZodBoolean>;
+            isolation: z.ZodOptional<z.ZodEnum<{
+                local: "local";
+                worktree: "worktree";
+            }>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">;
+    status: z.ZodEnum<{
+        completed: "completed";
+        active: "active";
+        paused: "paused";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    lastRunAt: z.ZodNullable<z.ZodString>;
+    pausedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    maxRuns: z.ZodNullable<z.ZodNumber>;
+    runs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        scheduledFor: z.ZodString;
+        startedAt: z.ZodString;
+        endedAt: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        agentId: z.ZodNullable<z.ZodGUID>;
+        workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        output: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StoredSchedule = z.infer<typeof StoredScheduleSchema>;
+export declare const ScheduleSummarySchema: z.ZodObject<{
+    name: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        active: "active";
+        paused: "paused";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"every">;
+        everyMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        agentId: z.ZodGUID;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"new-agent">;
+        config: z.ZodObject<{
+            provider: z.ZodString;
+            cwd: z.ZodString;
+            modeId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            thinkingOptionId: z.ZodOptional<z.ZodString>;
+            archiveOnFinish: z.ZodOptional<z.ZodBoolean>;
+            isolation: z.ZodOptional<z.ZodEnum<{
+                local: "local";
+                worktree: "worktree";
+            }>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">;
+    prompt: z.ZodString;
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    lastRunAt: z.ZodNullable<z.ZodString>;
+    pausedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    maxRuns: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ScheduleSummary = z.infer<typeof ScheduleSummarySchema>;
+export interface CreateScheduleInput {
+    name?: string | null;
+    prompt: string;
+    cadence: ScheduleCadence;
+    target: ScheduleTarget;
+    maxRuns?: number | null;
+    expiresAt?: string | null;
+    runOnCreate?: boolean | null;
+}
+export interface UpdateScheduleNewAgentConfig {
+    provider?: string;
+    model?: string | null;
+    modeId?: string | null;
+    thinkingOptionId?: string | null;
+    archiveOnFinish?: boolean;
+    isolation?: "local" | "worktree";
+    cwd?: string;
+}
+export interface UpdateScheduleInput {
+    id: string;
+    name?: string | null;
+    prompt?: string;
+    cadence?: ScheduleCadence;
+    newAgentConfig?: UpdateScheduleNewAgentConfig;
+    maxRuns?: number | null;
+    expiresAt?: string | null;
+}
+export interface ScheduleExecutionResult {
+    agentId: string | null;
+    output: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/schedule/types.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { AgentProviderSchema } from "../provider-manifest.js";
+export const ScheduleStatusSchema = z.enum(["active", "paused", "completed"]);
+export const ScheduleCadenceSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("every"),
+        everyMs: z.number().int().positive(),
+    }),
+    z.object({
+        type: z.literal("cron"),
+        expression: z.string().trim().min(1),
+        timezone: z.string().trim().min(1).optional(),
+    }),
+]);
+export const ScheduleTargetSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("agent"),
+        agentId: z.guid(),
+    }),
+    z.object({
+        type: z.literal("new-agent"),
+        config: z.object({
+            provider: AgentProviderSchema,
+            cwd: z.string().trim().min(1),
+            modeId: z.string().trim().min(1).optional(),
+            model: z.string().trim().min(1).optional(),
+            thinkingOptionId: z.string().trim().min(1).optional(),
+            archiveOnFinish: z.boolean().optional(),
+            isolation: z.enum(["local", "worktree"]).optional(),
+            title: z.string().trim().min(1).nullable().optional(),
+            providerOptions: z.record(z.string(), z.json()).optional(),
+            featureValues: z.record(z.string(), z.unknown()).optional(),
+            systemPrompt: z.string().optional(),
+            mcpServers: z.record(z.string(), z.unknown()).optional(),
+        }),
+    }),
+]);
+export const ScheduleRunSchema = z.object({
+    id: z.string(),
+    scheduledFor: z.string(),
+    startedAt: z.string(),
+    endedAt: z.string().nullable(),
+    status: z.enum(["running", "succeeded", "failed"]),
+    agentId: z.guid().nullable(),
+    workspaceId: z.string().nullable().optional(),
+    output: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const StoredScheduleSchema = z.object({
+    id: z.string(),
+    name: z.string().nullable(),
+    prompt: z.string().min(1),
+    cadence: ScheduleCadenceSchema,
+    target: ScheduleTargetSchema,
+    status: ScheduleStatusSchema,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    nextRunAt: z.string().nullable(),
+    lastRunAt: z.string().nullable(),
+    pausedAt: z.string().nullable(),
+    expiresAt: z.string().nullable(),
+    maxRuns: z.number().int().positive().nullable(),
+    runs: z.array(ScheduleRunSchema),
+});
+export const ScheduleSummarySchema = StoredScheduleSchema.omit({
+    runs: true,
+});
+//# sourceMappingURL=types.js.map

package/dist/search/text-match.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Ranked text matching shared by the app's pickers and the daemon's history
+ * search. A match is a tier plus the offset it was found at; lower is better on
+ * both, so callers sort ascending and never have to invent a scale.
+ *
+ * Typo tolerance is opt-in via `fuzzy`. The pickers leave it off — a combobox
+ * over a known list wants exact narrowing — while history search turns it on
+ * because the user is recalling a title from memory.
+ */
+export interface MatchScore {
+    tier: number;
+    offset: number;
+    spread?: number;
+}
+export interface MatchOptions {
+    /** Omit or pass null to match exactly. `fuzzyPolicyForToken` picks a policy. */
+    fuzzy?: FuzzyPolicy | null;
+    /**
+     * Match characters that appear in order but not adjacently, so `pasbab` finds
+     * `paseo-babysit`. Defaults to on. Turn it off where a near miss has to read as
+     * no match at all: it widens far enough that most typos hit something, and a
+     * list that preselects its first row would then act on that row when the user
+     * presses Enter expecting nothing to happen.
+     */
+    subsequence?: boolean;
+}
+/**
+ * How much a typo in one query token is forgiven. Short tokens get
+ * transpositions and nothing else: at four characters a free substitution turns
+ * "main" into "mail", "maid", and "rain", while a swap can only ever reach the
+ * word the user meant. Null means the token is matched exactly.
+ */
+export interface FuzzyPolicy {
+    maxEdits: number;
+    transpositionsOnly: boolean;
+}
+export declare function fuzzyPolicyForToken(token: string): FuzzyPolicy | null;
+export declare function scoreMatch(query: string, text: string, options?: MatchOptions): MatchScore | null;
+/** Match a query against a complete displayed path, including its separators. */
+export declare function scorePathMatch(query: string, path: string): MatchScore | null;
+export interface MatchRange {
+    start: number;
+    length: number;
+}
+/**
+ * Where a score's match actually landed, so a caller can mark it. Derived from
+ * a score rather than produced alongside one: ranking touches every candidate
+ * and needs no ranges, while only the handful of rows that get rendered do.
+ *
+ * The tier decides the shape. A substring hit is one span; a subsequence hit is
+ * the scattered characters it walked; a typo hit marks the whole word, because
+ * the characters the user got wrong are not in the text to point at.
+ */
+export declare function matchRanges(query: string, text: string, score: MatchScore): MatchRange[];
+export declare function compareMatchScores(a: MatchScore, b: MatchScore): number;
+export declare function tokenizeQuery(query: string): string[];
+export interface TextFieldsOptions {
+    /**
+     * Forgive typos. The budget is per token rather than per query, because a
+     * query mixes long words that can absorb an edit with short ones that cannot.
+     */
+    typoTolerant?: boolean;
+    /**
+     * See `MatchOptions.subsequence`. Applied per token, so turning it off means
+     * every token has to appear as a run of adjacent characters in some field —
+     * `lab des` still matches "Label as Design", `labdes` no longer does.
+     */
+    subsequence?: boolean;
+}
+export declare function scoreTextFields(query: string, fields: string[], options?: TextFieldsOptions): MatchScore | null;
+//# sourceMappingURL=text-match.d.ts.map