Skip to content

YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context

16.3 KB
Raw Blame
// screenpipe — AI that knows everything you've seen, said, or heard
// https://screenpipe.com
import { afterEach, beforeEach, expect, test } from "bun:test";
import { mkdtempSync, writeFileSync, readFileSync, statSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import extension, { workflowIndex } from "./workflow-workspace";
import { compactGlmToolResultText } from "./lib/glm-protocol";
let cwd:string, dir:string, originalTask:string|undefined, tool:any, server:any, requests:any[];
beforeEach(()=>{
  cwd=process.cwd();originalTask=process.env.SCREENPIPE_PIPE_NAME;
  dir=mkdtempSync(join(tmpdir(),"workflow-tool-"));process.chdir(dir);
  process.env.SCREENPIPE_PIPE_NAME="workflow-review";requests=[];
  server=Bun.serve({port:0,hostname:"127.0.0.1",fetch:async(req)=>{
    expect(req.headers.get("authorization")).toBe("Bearer fixture-capability");
    const body=req.method==="POST"?await req.json():null;requests.push(body);
    return Response.json({saved:true,revision:2});
  }});
  writeFileSync(join(dir,".screenpipe-permissions.json"),JSON.stringify({api_base:`http://127.0.0.1:${server.port}`,pipe_token:"fixture-capability"}));
  extension({registerTool:(t:any)=>{tool=t}} as any);
});
afterEach(()=>{server.stop(true);process.chdir(cwd);rmSync(dir,{recursive:true});if(originalTask===undefined)delete process.env.SCREENPIPE_PIPE_NAME;else process.env.SCREENPIPE_PIPE_NAME=originalTask;});
test("structured saves serialize quotes and JSON-like source content without shell construction",async()=>{
  const payload={title:'Literal ]} and "quote"',sources:[{quote:'$() `command` \\ \n trailing ]}'}]};
  const result=await tool.execute("id",{action:"handoff",expected_revision:1,draft_id:"a",assignee:"workflow-review",note:"checked",payload},new AbortController().signal);
  expect(result.isError).not.toBe(true);expect(requests[0].payload).toEqual(payload);expect(requests[0].task).toBe("workflow-review");
});
test("server conflicts are errors, not success text",async()=>{
  server.reload({fetch:()=>Response.json({error:"Workspace changed"},{status:409})});
  await expect(tool.execute("id",{action:"publish",expected_revision:1,catalog_revision:1,draft_id:"a"},new AbortController().signal)).rejects.toThrow("Workspace changed");
});
test("missing capability never falls back to a broad owner token",async()=>{
  writeFileSync(join(dir,".screenpipe-permissions.json"),"{}");
  await expect(tool.execute("id",{action:"context"},new AbortController().signal)).rejects.toThrow("Local recorder capability unavailable");
  expect(requests).toHaveLength(0);
});
test("an already-aborted task cannot save",async()=>{
  const abort=new AbortController();abort.abort();
  await expect(tool.execute("id",{action:"publish",expected_revision:1,catalog_revision:1,draft_id:"a"},abort.signal)).rejects.toThrow();
  expect(requests).toHaveLength(0);
});

function contextFixture(payload:any = {title:"Invoice review",evidence:[{quote:"Full source"}]}) {
  const draft={id:"draft-a",status:"open",assignee:"workflow-review",payload,history:[{note:"Check the source"}]};
  const workflow={id:"wf-a",title:"Existing invoice review",stages:[{procedure:[{text:"Existing action"}]}]};
  server.reload({fetch:(req:Request)=>Response.json(new URL(req.url).pathname==="/workflows/workspace"
    ? {workspace:{revision:7,cycle:{id:"cycle",notes:{large:"not in index"}},drafts:{"draft-a":draft}},catalogRevision:4,ready:true}
    : {workflows:[workflow],profile:{},outputContract:"Exact output contract"})});
  return {draft,workflow};
}
test("context index avoids hiding full drafts behind shared harness truncation",async()=>{
  contextFixture({title:"Invoice review",evidence:"x".repeat(40000)});
  const result=await tool.execute("id",{action:"context"},new AbortController().signal);
  const index=JSON.parse(result.content[0].text);
  expect(index.revision).toBe(7);expect(index.catalogRevision).toBe(4);
  expect(index.drafts[0].id).toBe("draft-a");expect(index.drafts[0].payload).toBeUndefined();
  expect(index.workflows[0].stages).toBeUndefined();expect(index.cycle.notes).toBeUndefined();
  expect(result.content[0].text.length).toBeLessThan(24000);
});
test("explicit context selectors preserve the exact draft and catalog record",async()=>{
  const {draft,workflow}=contextFixture();
  const call=async(input:any)=>JSON.parse((await tool.execute("id",{action:"context",...input},new AbortController().signal)).content[0].text);
  expect((await call({draft_id:"draft-a"})).draft).toEqual(draft);
  expect((await call({workflow_id:"wf-a"})).workflow).toEqual(workflow);
  expect((await call({draft_id:"draft-a"})).outputContract).toBe("Exact output contract");
  for (const input of [{draft_id:"draft-a"},{workflow_id:"wf-a"}]) {
    expect((await call(input)).publicationShape).toContain("not publish the outer");
    expect((await call(input)).publicationShape).toContain("outputContract.workflows");
  }
  await expect(tool.execute("id",{action:"context",draft_id:"missing"},new AbortController().signal)).rejects.toThrow("not found");
});
test("oversized selected context is preserved in a private readable snapshot",async()=>{
  const {draft}=contextFixture({title:"Invoice review",evidence:"exact source ".repeat(4000)});
  const result=await tool.execute("id",{action:"context",draft_id:"draft-a"},new AbortController().signal);
  const pointer=JSON.parse(result.content[0].text);
  expect(result.content[0].text.length).toBeLessThan(24000);
  expect(JSON.parse(readFileSync(pointer.path,"utf8")).draft).toEqual(draft);
  expect(statSync(pointer.path).mode & 0o777).toBe(0o600);
  expect(pointer.revision).toBe(7);expect(pointer.catalogRevision).toBe(4);
});
test("medium context survives the Private transport with an exact snapshot",async()=>{
  const {draft}=contextFixture({title:"Invoice review",evidence:"source fragment ".repeat(800)});
  const result=await tool.execute("id",{action:"context",draft_id:"draft-a"},new AbortController().signal);
  // The native failure lived between the old 24K inline limit and Private's
  // 8K tool-text limit: its JSON became unparseable, with no snapshot to read.
  const delivered=compactGlmToolResultText(result.content[0].text);
  const pointer=JSON.parse(delivered);
  expect(delivered).toBe(result.content[0].text);
  expect(JSON.parse(readFileSync(pointer.path,"utf8")).draft).toEqual(draft);
  expect(pointer.revision).toBe(7);
  expect(pointer.catalogRevision).toBe(4);
});

test("mistyped draft selectors return exact owned ids without substituting or writing",async()=>{
  contextFixture();
  await expect(tool.execute("id",{action:"context",draft_id:"draft-b"},new AbortController().signal))
    .rejects.toThrow(/"id":"draft-a","title":"Invoice review"/);
});
test.each(["handoff", "publish", "reject"])("unknown draft %s returns exact candidates but never retries the mutation",async(action)=>{
  let writes=0;
  server.reload({fetch:(req:Request)=>{
    if(req.method==="POST"){writes++;return Response.json({error:"Draft not found."},{status:409});}
    return Response.json({workspace:{drafts:{a:{id:"exact-id",status:"open",assignee:"workflow-review",payload:{title:"Review invoice"}},b:{id:"other-owner",status:"open",assignee:"workflow-deepen"}}}});
  }});
  const error=await tool.execute("id",{action,expected_revision:1,catalog_revision:1,draft_id:"typo",note:"repair"},new AbortController().signal).catch((e:Error)=>e);
  expect(error).toBeInstanceOf(Error);expect(writes).toBe(1);
  expect(error.message).toContain("exact-id");
  expect(error.message).not.toContain("other-owner");
  expect(error.message).toContain("No changes were saved");
});


test("publication returns remaining work with current revisions, distinct from its save receipt",async()=>{
  server.reload({fetch:(req:Request)=>Response.json(req.method==="POST"
    ? {revision:8,changes:{created:1},checkedThrough:"previous-window"}
    : {workspace:{revision:12,cycle:{status:"running"},drafts:{done:{status:"published"}}},catalogRevision:8,canFinish:true})});
  const result=await tool.execute("id",{action:"publish",expected_revision:1,catalog_revision:1,draft_id:"done"},new AbortController().signal);
  expect(result.isError).not.toBe(true);
  expect(JSON.parse(result.content[0].text)).toMatchObject({revision:8,remaining:{revision:12,catalogRevision:8,cycleStatus:"running",canFinish:true,openDrafts:[]}});
});
test("a failed state read after saving preserves the successful receipt",async()=>{
  let writes=0;
  server.reload({fetch:(req:Request)=>{
    if(req.method==="POST"){writes++;return Response.json({revision:8,changes:{created:1}});}
    return Response.json({error:"Recorder unavailable"},{status:503});
  }});
  const result=await tool.execute("id",{action:"publish",expected_revision:1,catalog_revision:1,draft_id:"done"},new AbortController().signal);
  expect(result.isError).not.toBe(true);expect(writes).toBe(1);
  expect(JSON.parse(result.content[0].text)).toMatchObject({revision:8,remaining:{unavailable:true}});
});

test("maintenance index exposes timing coverage and source dates without source text", () => {
  const item = workflowIndex({id:"old",title:"Receipts",evidence:[
    {timestamp:"2026-09-18T12:08:00Z",detail:"private source"},
    {timestamp:"2026-09-18T05:00:00-07:00",detail:"private source"},
    {timestamp:"invalid"}],timingRuns:[{start:{quote:"private"}}]});
  expect(item.timing.runCount).toBe(1);
  expect(item.sourceRange).toEqual({first:"2026-09-18T05:00:00-07:00",last:"2026-09-18T12:08:00Z"});
  expect(JSON.stringify(item)).not.toContain("private");
  expect(workflowIndex({id:"empty",evidence:[],timingRuns:null})).toMatchObject({timing:{runCount:0},sourceRange:null});
});
test("both index and selected workflow retain available history independently of cycle",async()=>{
  server.reload({fetch:(req:Request)=>Response.json(new URL(req.url).pathname==="/workflows/workspace"
    ? {workspace:{revision:7,cycle:{start:"2026-09-20T00:00:00Z",end:"2026-09-21T00:00:00Z"},drafts:{}},catalogRevision:4,ready:true}
    : {historyStart:"2026-06-23T00:00:00Z",workflows:[{id:"old",title:"Receipts",timingRuns:[],evidence:[{timestamp:"2026-09-18T12:00:00Z"}]}],outputContract:"contract"})});
  for(const input of [{action:"context"},{action:"context",workflow_id:"old"}]) {
    const result=JSON.parse((await tool.execute("id",input,new AbortController().signal)).content[0].text);
    expect(result.historyStart).toBe("2026-06-23T00:00:00Z");
    expect(result.cycle.start).toBe("2026-09-20T00:00:00Z");
  }
});

// Missing revisions are invalid input, not a concurrent-write conflict.
test("finish explains missing revisions before making a request and accepts a corrected call",async()=>{
  for(const input of [
    {action:"finish",note:"Done"},
    {action:"finish",expected_revision:"1",note:"Done"},
    {action:"finish",expected_revision:-1,note:"Done"},
  ]) await expect(tool.execute("id",input,new AbortController().signal)).rejects.toThrow("expected_revision is required");
  await expect(tool.execute("id",{action:"finish",expected_revision:1,note:"Done"},new AbortController().signal)).rejects.toThrow("catalog_revision is required");
  expect(requests).toHaveLength(0);
  const result=await tool.execute("id",{action:"finish",expected_revision:1,catalog_revision:4,note:"Done"},new AbortController().signal);
  expect(JSON.parse(result.content[0].text).saved).toBe(true);
  expect(requests[0]).toMatchObject({action:"finish",expected_revision:1,catalog_revision:4});
});
test("Maintenance can finish with its workspace revision without a publication revision",async()=>{
  process.env.SCREENPIPE_PIPE_NAME="workflow-maintain";
  extension({registerTool:(t:any)=>{tool=t}} as any);
  const result=await tool.execute("id",{action:"finish",expected_revision:1,note:"Investigation handed to Review"},new AbortController().signal);
  expect(JSON.parse(result.content[0].text).saved).toBe(true);
  expect(requests[0]).toMatchObject({task:"workflow-maintain",action:"finish",expected_revision:1});
  expect(requests[0].catalog_revision).toBeUndefined();
});
test("workspace selects the single-workflow contract while legacy clients keep the batch contract",async()=>{
  server.reload({fetch:(req:Request)=>Response.json(new URL(req.url).pathname==="/workflows/workspace"
    ? {workspace:{revision:1,drafts:{a:{id:"a",status:"open",assignee:"workflow-review",payload:{}}}},catalogRevision:1}
    : {workflows:[{id:"wf-a"}],outputContract:"legacy batch",workflowOutputContract:"single workflow"})});
  for(const selector of [{draft_id:"a"},{workflow_id:"wf-a"}]) {
    const result=JSON.parse((await tool.execute("id",{action:"context",...selector},new AbortController().signal)).content[0].text);
    expect(result.outputContract).toBe("single workflow");
    expect(result.publicationShape).toContain("one workflow object");
    expect(JSON.stringify(result)).not.toContain("legacy batch");
  }
});
test("batch and workspace contracts describe the same workflow fields",()=>{
  const batch=readFileSync(new URL("../pipes/workflow-discovery/output.md",import.meta.url),"utf8");
  const item=readFileSync(new URL("../pipes/workflow-review/output.md",import.meta.url),"utf8").trim();
  expect(item.startsWith('{"id":')).toBe(true);
  expect(batch).toContain(`"workflows":[${item}]`);
});


test("maintenance sees neglected empty steps and historical sources without private content", () => {
  const index = workflowIndex({ id:"legacy", lastReviewedAt:"2026-09-10T10:00:00Z", userEdits:{stages:true}, evidence:[], stages:[
    {procedure:[], evidence:[{timestamp:"2026-09-01T10:00:00Z",quote:"private"}], screenshot:{frameId:1}},
    {procedure:[{text:"private action"}], evidence:[], screenshot:{visualVerified:true,dataUrl:"private pixels"}}
  ]});
  expect(index.evidenceCoverage).toEqual({stageCount:2,stagesWithProcedure:1,stagesWithVerifiedScreenshot:1});
  expect(index.lastReviewedAt).toBe("2026-09-10T10:00:00Z");
  expect(index.sourceRange?.first).toBe("2026-09-01T10:00:00Z");
  expect(index.userEdits).toEqual({stages:true});
  expect(JSON.stringify(index)).not.toContain("private");
});


test("new-cycle context exposes prior investigation without treating it as workflow evidence",async()=>{
  const notes={"workflow-maintain":{cycleId:"previous",through:"2026-09-21T12:00:00Z",note:"wf-a: earlier recording unavailable; recheck with new evidence.",truncated:false}};
  server.reload({fetch:(req:Request)=>Response.json(new URL(req.url).pathname==="/workflows/workspace"
    ? {workspace:{revision:9,cycle:{id:"next"},drafts:{},researchNotes:notes},catalogRevision:4,ready:true}
    : {workflows:[{id:"wf-a",title:"Receipts"}],profile:{}})});
  const result=JSON.parse((await tool.execute("id",{action:"context"},new AbortController().signal)).content[0].text);
  expect(result.researchNotes).toEqual(notes);
  expect(result.cycle.id).toBe("next");
  expect(result.workflows[0].evidence).toBeUndefined();
});

test("retryable publication state is visible in the draft index and full record", async () => {
  const {draft} = contextFixture();
  (draft as any).publicationRetry = {retryable:true};
  const index = JSON.parse((await tool.execute("id", {action:"context"}, new AbortController().signal)).content[0].text);
  expect(index.drafts[0].publicationRetry).toEqual({retryable:true});
  const selected = JSON.parse((await tool.execute("id", {action:"context",draft_id:"draft-a"}, new AbortController().signal)).content[0].text);
  expect(selected.draft.publicationRetry).toEqual({retryable:true});
});

test("checkpoint uses the existing durable writer without finishing or publishing", async () => {
  expect(tool.parameters.properties.action.enum).toContain("checkpoint");
  const result = await tool.execute("id", {action:"checkpoint",expected_revision:1,note:"Inspected first interval. Next: retry the narrower failed query."}, new AbortController().signal);
  expect(JSON.parse(result.content[0].text).saved).toBe(true);
  expect(requests[0]).toMatchObject({action:"checkpoint",task:"workflow-review",expected_revision:1});
  expect(requests.filter(Boolean)).toHaveLength(1);
});
test("resumed context exposes unfinished checkpoints", async () => {
  server.reload({fetch:(req:Request)=>Response.json(req.url.endsWith("/context") ? {workflows:[],profile:{}} : {
    workspace:{revision:3,cycle:{status:"running",checkpoints:{"workflow-discover":{note:"Read interval A; B failed",savedAt:"2026-09-29T10:00:00Z"}}}},catalogRevision:1,
  })});
  const result = await tool.execute("id",{action:"context"},new AbortController().signal);
  expect(JSON.parse(result.content[0].text).cycle.checkpoints["workflow-discover"].note).toBe("Read interval A; B failed");
});